diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Analysis_Stage_2_S2_00.md b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Analysis_Stage_2_S2_00.md new file mode 100644 index 00000000..aa194889 --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Analysis_Stage_2_S2_00.md @@ -0,0 +1,103 @@ +# Stage 2 - S2_00 분석 + +## Executive Summary + +현행 배포본 `Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml`은 Stage 1 Part 1–4의 사건 자료를 받아 S2_10용 claim-neutral 문맥과 전달 계획을 만드는 비 LLM ingress 명세다. `Agent.name`은 `Stage_2_S2_00_v2`, 버전은 `1.2.0`이다. 실제 Agent task는 **request 준비**와 **deterministic ingress** 두 개이며, C00·C05·C10·C15는 두 번째 task의 inline Python 안에서 수행되는 논리 단계다. 두 task 모두 `code-executor.run_code`를 사용하고 localdocs로 파일을 읽고 쓴다. + +첫 task의 `prepare_request(...)` 함수는 외부 문자열 인자 네 개를 정확히 6필드의 `s2_00_request.json`으로 만들어 고정 경로에 저장하고 read-back을 확인하도록 구현되어 있다. 그러나 배포 YAML에는 backend가 그 네 인자를 함수에 주입하는 실행 결속이 없다. 현재 inline 코드의 직접 실행 진입점은 `PREPARE_ARGUMENT_BINDING_UNVERIFIED`를 출력하고 종료 코드 2로 실패한다. 따라서 이 분석서의 DAG와 산출물은 **구현된 함수 및 선언된 계약**을 설명하며, 현재 배포본의 사건별 실실행 성공을 의미하지 않는다. 더구나 현재 release는 `DEV_FIXTURE_RELEASE / DRAFT_NOT_EXECUTABLE`이고 ingress가 DEV fixture의 실제 사건 발행을 거부한다. + +## 전체 작업 DAG와 책임 경계 + +```text +외부 실행자: request_id, attempt_id, stage1_run_root_ref, + stage1_deployment_root_ref 제공; workspace 호출·직렬화 책임 + │ + ▼ +IN → Task_S2_00_prepare_request → Task_S2_00_deterministic_ingress → OUT + │ 6필드 request 생성·검증 │ 고정 request/Stage 1/release·자산 hydration + │ localdocs write/read-back ├─ C00: 입력 계약·출처/무결성 검증 + ▼ ├─ C05: review 항목 정규화·보존 검사 +W/stage2_control/s2_00_request.json ├─ C10: 사건·증거·당사자·slot 문맥 구성 + └─ C15: bundle/route·결과 발행 + → O/ingress/ingress_status.json 마지막 기록 +``` + +YAML의 `task_procedure`는 `IN → prepare → ingress → OUT`의 `nexts`/`wait_until` 순서를 선언한다. `Stages[0].prevs`와 `nexts`는 빈 배열이므로 다른 Stage Agent로의 호출은 이 YAML 안에 없다. ingress 내부의 C00–C15는 별도 MCP task나 각각의 저장 파일이 아니다. 준비 task가 성공해야 ingress가 시작되는 **backend success-only gate**, 그리고 동일 workspace의 고정 request 경로에 대한 **다른 실행의 덮어쓰기 차단**은 workflow·deployment 계약에서 모두 `UNVERIFIED`다. + +여기서 `W/`는 localdocs의 사용자·workspace 논리 루트, `A/`는 `W/Default_Agent/Stage_2_Clean/`, `U/`는 `W//`, `D/`는 `W//`, `O/`는 `W/stage2_runs/by-binding//`를 뜻한다. 이들은 Dropbox 저장소의 물리 경로가 아니다. 배포 저장소의 대응 패키지 루트는 `Default_Agent/Stage_2_Clean/`이다. `<...>` 값은 사건·release·실행 입력으로 결정되며 현재 자료에서 특정 파일명으로 확정할 수 없다. + +## 실제 실행단위와 prompt 구성 + +| 실제 Agent task | 호출·코드 위치 | 하는 일 | LLM prompt | +|---|---|---|---| +| `Task_S2_00_prepare_request` | `code-executor.run_code`; YAML `/Agent/Stages/0/tasks/0/parameters/code` | 네 인자를 검사하고 6필드 canonical JSON을 `W/stage2_control/s2_00_request.json`에 쓰고 동일 바이트를 다시 읽어 확인한다. | 없음 | +| `Task_S2_00_deterministic_ingress` | `code-executor.run_code`; YAML `/Agent/Stages/0/tasks/1/parameters/code` | request·release·Stage 1 자료·잠금 자산을 읽고 C00–C15를 한 번의 Python 실행에서 처리한 뒤 결과를 발행한다. | 없음 | + +두 task의 파라미터는 `language: python`, `requirements: httpx==0.28.1`, `network: agent-network`, `timeout: 300`이다. `localdocs` 서버는 `http://mcp-localdocs:8012/mcp`, `code-executor` 서버는 `https://code-executor.mcp.eroomai.com/mcp`로 선언되어 있다. YAML의 `description`과 주석은 실행 명세이며 system/user prompt, prompt template, 모델 호출 구성이 아니다. `run_code`에 전달되는 실제 본문은 각 task의 `parameters.code`에 내장된 Python이다. `.py`/`.txt` mirror는 빌드·검증용 대응본이지 런타임의 추가 import가 아니다. + +첫 task의 `build_request`와 `prepare_request`는 호출 가능한 함수로 존재한다. ID 형식, NFC 상대경로, 정확한 필드 집합을 확인하고 UTF-8 canonical JSON과 끝의 LF를 만든다. localdocs `write_binary_file(overwrite=true)` 뒤 `read_binary_doc`를 비교하며 성공 시 SHA-256 등을 함수 반환값으로 제공한다. 다만 `__main__`은 외부 인자 결속이 없음을 명시적으로 실패 처리한다. ingress의 직접 진입점은 `run_inline_mcp()`이며 localdocs에서 필요한 바이너리를 읽어 code-executor 임시 디렉터리에 hydrate하고 core를 실행한다. 입력은 두 차례 읽어 바이트 일치를 검사하고, 원격 발행은 일반 산출물을 먼저 write/read-back한 다음 `ingress/ingress_status.json`을 마지막에 쓴다. + +## In & Out 설명 + +모든 `.json` 입력·출력은 JSON 파일이다. `s2_00_request.json`과 발행 결과는 canonical UTF-8 JSON이며, 개별 Stage 1 원본의 바이트·스키마 검증 규칙은 release와 ingress 구현이 지배한다. 아래 `A/`, `U/`, `D/`, `O/` 표기는 앞 절의 **localdocs 논리 경로**다. + +| 단계 | Input: 정확한 이름·형식·source | 역할 | +|---|---|---| +| prepare | `request_id`, `attempt_id`, `stage1_run_root_ref`, `stage1_deployment_root_ref`: 외부 문자열 인자, 파일 아님 | ID와 Stage 1 사건·배포 루트를 결속할 값. backend 공급 방식은 미검증. | +| ingress | `W/stage2_control/s2_00_request.json`: JSON, 정확히 `schema_version`, `workflow_id`, `request_id`, `attempt_id`, `stage1_run_root_ref`, `stage1_deployment_root_ref` 6필드 | prepare의 고정 출력. 상수값은 `stage2_s2_00_execution_request.v1` 및 `S2_00`. | +| ingress: Stage 1 P1 | `U/evidence_indexed.json`, `U/evidence_event_candidates.json`, `U/client_goal.json`, `U/routing/domain_screening.json`, `U/routing/domain_activation_manifest.json`, `U/quality_gates/B1_evidence_indexed_gate.json`, `U/quality_gates/B2_event_candidates_gate.json`, `U/quality_gates/stage1_part1_soft_gate_handoff.json`: 각 JSON | 증거·목표·도메인 routing 및 P1 gate/handoff. | +| ingress: Stage 1 P2 | `U/BO.json`, `U/signals/signal_manifest.json`, `U/quality_gates/stage1_part2_review_handoff.json`: 각 JSON | BO·신호 목록·P2 handoff. | +| ingress: Stage 1 P3 | `U/legal_effect_structures.json`, `U/quality_gates/stage1_part3_review_handoff.json`: 각 JSON | 법률효과 구조·P3 handoff. | +| ingress: Stage 1 P4 | `U/Fact_Ledger_base.json`, `U/stage1_tmp/fact_ledger/fact_ledger_writer_report.json`, `U/quality_gates/stage1_part4_review_handoff.json`: 각 JSON | 사실 ledger·writer report·P4 handoff. | +| ingress: 동적 신호 | `U/signals/`: 각 JSON | `signal_manifest.json` 행에서 확장하므로 정확한 basename·개수는 사건별 manifest가 있어야 확정된다. `U/routing/domain_activation_manifest.json`과 이름이 비슷한 신호 파일이 있더라도 별도 경로다. | +| ingress: Stage 1 배포 | `D/`: JSON/JSON Schema, 총 55개 고정 경로 | Stage 1 runtime manifest, registry/config/schema를 release의 경로·해시로 결속한다. 정확한 55개 항목은 `A/manifest/stage2_release.json#/dependency_locks/stage1/concrete_paths`가 정의한다. | +| ingress: Stage 2 배포 | `A/manifest/stage2_release.json`, `A/manifest/module_manifest.json`, `A/schemas/ingress.schema.json`, `A/schemas/context.schema.json`, `A/schemas/review_status.schema.json` 및 `A/` 49개: JSON·JSON Schema·YAML | release/모듈·출력 검증 기준 및 직접 의존 자산. 아래 고정 자산 표에 배포 경로를 적었다. | + +| 단계·분기 | Output: 정확한 이름·형식·저장 folder | 의미 | +|---|---|---| +| prepare | `W/stage2_control/s2_00_request.json`: JSON; `W/stage2_control/` | ingress가 소비할 고정 제어 request. 성공 반환 객체는 함수 응답이지 별도 파일이 아니다. | +| ingress: 공통 | `O/ingress/stage1_input_manifest.json`, `O/ingress/intake_report.json`, `O/review/issue_ledger.base.json`, `O/ingress/ingress_status.json`: 각 JSON; `O/ingress/`·`O/review/` | 입력 출처·수용 결과·review 이슈·route/barrier. `ingress_status.json`은 마지막에 기록한다. | +| ingress: 정상 route | `O/context/case_context.json`, `evidence_inventory.json`, `object_registry.json`, `party_and_title_context.json`, `slot_crosswalk.json`, `cluster_plan.json`, `bundle_plan.json`: 각 JSON; `O/context/` | S2_10용 정규화 문맥과 cluster·bundle 계획. 공통 4개를 합쳐 고정 11개. | +| ingress: 정상 route의 가변 파일 | `O/context/cluster_slices/.json`: JSON; `O/context/cluster_slices/` | 실행 가능 cluster마다 1개. 최종 ID 집합은 해당 사건의 계획으로 정해지므로 정상 출력 총수는 `11 + E`(`E`=실행 가능 cluster 수). | +| ingress: 진단 route | `O/ingress/technical_diagnostic.json`: JSON; `O/ingress/` | `TO_S2_40_STATUS_ONLY`일 때 공통 4개와 함께 총 5개. 정상 `context/` 파일은 이 분기에서 생성하지 않는다. | + +ingress는 먼저 code-executor의 임시 `liti-s2-00-*` 디렉터리에 입력 및 `core_output/`을 구성한다. 최종 저장 장소는 위 `O/` localdocs 경로이며, 임시 경로는 배포 산출물 경로가 아니다. `run_binding_digest`는 입력 집합·Stage 2 release·알고리즘·release class 결속으로 정해져 `O/`를 결정한다. `attempt_id`만 바꾼다고 출력 루트가 바뀌는 계약은 아니다. `run_code`의 JSON stdout 결과도 출력 파일과 구별해야 한다. + +## 작업용 고정 자산 + +아래 표에서 `A/<상대경로>`는 **배포 시 localdocs의 `Default_Agent/Stage_2_Clean/<상대경로>`**이고, 저장소에도 같은 상대경로의 파일이 있다. 쉼표로 열거한 basename은 앞의 배포 directory와 각각 결합한다. `R/` 표기는 혼동을 피하려고 사용하지 않는다. 런타임 hydration 자산과 빌드·결속 명세는 역할을 구분했다. + +| 정확한 배포 경로 (`A/` 이하) | 형식·개수 | 역할·실행 시점 | +|---|---:|---| +| `agent_scripts/Stage_2_S2_00.yml` | YAML 1 | 이 Agent의 현행 두 task와 inline code. | +| `manifest/stage2_release.json` | JSON 1 | release class·상태, Stage 1 입력 16+동적 항목, Stage 1 배포 잠금 55개, Stage 2 직접 잠금 49개, 알고리즘·출력 계약. ingress에서 읽고 hash 검증. | +| `manifest/module_manifest.json` | JSON 1 | 모듈 고정 manifest; ingress hydration 대상. | +| `schemas/ingress.schema.json`, `schemas/context.schema.json`, `schemas/review_status.schema.json` | JSON Schema 3 | request/입력·context·review/status 형태의 ingress 검증 기준; ingress hydration 대상. | +| `agent_scripts/Stage_2_S2_10.yml`, `deployment/stage2_s2_10_llm_binding.yml`, `registry/authority/authority_registry.yml`, `manifest/authority_release.json` | YAML 3, JSON 1 | Stage 2 직접 잠금의 S2_10 Agent·LLM/authority 결속 4개. ingress가 경로·hash로 확인하나 S2_10 호출 자체는 하지 않는다. | +| `registry/substantive/EC-00_contract_general.yml`, `E-01_juristic_act_validity.yml`, `E-02_contract_money_claim.yml`, `E-03_parties_liability_succession.yml`, `E-04_unjust_enrichment.yml`, `E-05_tort_general.yml`, `E-06_professional_liability.yml`, `E-07_construction_defect.yml`, `E-08_lease_deposit.yml`, `E-09_registry_transfer_claims.yml`, `E-10_secured_registry.yml`, `E-11_possession_vindication.yml`, `E-12_co_ownership_boundary.yml`, `E-13_creditor_preservation.yml`, `E-14_execution_linked_claims.yml`, `E-15_succession_family_property.yml`, `E-16_negotiable_instruments.yml`, `E-17_labor_wage_claims.yml`, `E-18_org_resolution_status.yml`, `E-19_insurance_claims.yml`, `E-20_ip_claims.yml`, `E-21_media_personality_rights.yml` | YAML 22 | Stage 2 직접 잠금 substantive registry. 각 basename의 전체 배포 경로는 `A/registry/substantive/`이다. | +| `profiles/crosscut/E-00_residual_unrouted.yml`, `X1_notice_lifecycle.yml`, `X2_asset_identity_lineage.yml`, `X3_procedure_standing_relief.yml`, `X4_response_admission_defense.yml` | YAML 5 | Stage 2 직접 잠금 crosscut profile; 전체 배포 경로는 `A/profiles/crosscut/`. | +| `profiles/special_law/SL-AUTO_motor_vehicle.yml`, `SL-INDUSTRIAL_ACCIDENT.yml`, `SL-PRODUCT_LIABILITY.yml`, `SL-RESIDENTIAL_LEASE.yml`, `SL-COMMERCIAL_LEASE.yml`, `SL-LABOR.yml`, `SL-STATE_LIABILITY.yml`, `SL-IP-PATENT.yml`, `SL-IP-COPYRIGHT.yml`, `SL-IP-OTHER.yml`, `SL-MEDIA.yml`, `SL-TRANSPORT_MARITIME.yml`, `SL-CONSUMER_CONTRACT.yml` | YAML 13 | Stage 2 직접 잠금 특별법 profile; 전체 배포 경로는 `A/profiles/special_law/`. | +| `profiles/overlays/ACTIO-MORTGAGE.yml`, `ACTIO-MORTGAGE-CREATION.yml`, `ACTIO-ENCUMBERED-TRANSFER.yml`, `ACTIO-PRESERVED-CLAIM-BUNDLE.yml`, `ACTIO-DEFENSE-MAP.yml` | YAML 5 | Stage 2 직접 잠금 overlay; 전체 배포 경로는 `A/profiles/overlays/`. | +| `workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml` | YAML 1 | 두 task 순서·고정 request·외부 인자와 미검증 backend 항목을 선언하는 workflow 계약; ingress의 사건별 입력 파일은 아님. | +| `deployment/stage2_code_executor_binding.yml` | YAML 1 | S2_00 code-executor 결속, task 포인터·자산 hash·localdocs allowlist·live admission 상태를 선언하는 배포 계약. | +| `manifest/s2_00_inline_code_receipt.json` | JSON 1 | prepare/ingress inline code와 mirror의 정적 parity receipt. `PASS`는 live 실행 증거가 아니다. | +| `runtime/s2_00_prepare_request.py`, `runtime/s2_00_prepare_request.txt`, `runtime/s2_00_ingress.py`, `runtime/s2_00_ingress.txt` | Python 2, text 2 | inline code의 빌드·검증 mirror. YAML 직접 실행은 이 파일을 import하지 않는다. | +| `offline_build/build_s2_00_inline_projection.py`, `offline_build/build_s2_00_inline_projection.txt`, `schemas/deployment.schema.json` | Python 1, text 1, JSON Schema 1 | projection 생성·배포 계약 검사에 사용하는 offline 자산. 사건 ingress의 별도 실행 task가 아니다. | + +`release.dependency_locks.stage1.concrete_paths`의 55개 파일은 위 Stage 2 패키지에 복제되는 것이 아니라 `D/`에서 참조되는 Stage 1 배포 자산이다. `stage2_direct`의 49개는 위 표의 S2_10/authority 4개 + substantive 22개 + crosscut 5개 + special_law 13개 + overlays 5개다. 이 결속은 자산 존재·hash 확인과 downstream 선택 가능성을 위한 것이며, 49개 본문 전체가 S2_10 prompt에 들어간다는 뜻은 아니다. + +## Upstream/Downstream 설명 + +Upstream은 Stage 1의 P1–P4 사건 산출물 16개, `signal_manifest.json`에서 펼친 추가 신호 파일, Stage 1 배포 잠금 55개 및 네 외부 인자를 제공할 호출자다. 네 인자의 전달과 동일 workspace 동시 실행 제어는 외부 backend/orchestrator 경계에 있다. prepare가 고정 request를 쓰면 ingress가 그것을 다시 읽어 path/ID, release 및 원본 bytes와의 결속을 검증한다. `W/stage2_control/s2_00_request.json`은 Stage 1 고정 handoff 16개에 속하지 않는다. + +Downstream에서 정상 route는 `TO_S2_10` 또는 `TO_S2_10_WITH_ISSUES`이고, 진단 route는 `TO_S2_40_STATUS_ONLY`다. S2_00은 status barrier와 bundle/cluster plan을 발행할 뿐 S2_10·S2_40 Agent를 이 YAML에서 직접 호출하지 않는다. 외부 실행자는 `O/ingress/ingress_status.json`과 해당 분기의 완전한 산출물 집합을 검증해 후속 호출을 조립해야 한다. S2_10용 선택 context·cluster case payload는 후속 handoff의 필드/구성 문제이지 S2_00이 고정 파일명으로 별도 발행하는 파일이라고 간주할 수 없다. 진단 route에는 정상 `context/` 산출물이 없으므로 S2_10으로 보내는 경로가 아니다. + +## 구현과 계약 사이의 확인사항·잔여 한계 + +1. **네 인자·실행 환경 결속 부재:** 함수의 생성·검증·저장 구현과 offline 검증은 존재한다. 그러나 현행 task의 `__main__`은 항상 `PREPARE_ARGUMENT_BINDING_UNVERIFIED`로 종료한다. backend가 네 값을 함수에 넘기는 방식과 `{{__user_hash__}}`·`{{__workspace_hash__}}` 치환/인증의 실실행 증거가 없어, 현재 배포 YAML만으로 request 생성 완료나 두-task 실실행을 주장할 수 없다. +2. **순서와 배타성 미검증:** `task_procedure.wait_until`은 순서 선언이다. prepare 실패 시 ingress 차단을 backend가 보장하는지, request 저장부터 ingress의 두 차례 읽기와 입력 hydration 완료까지 동일 workspace의 다른 실행이 고정 경로를 덮어쓰지 못하는지는 미확인이다. 두 번 읽어 일치를 검사해도 첫 읽기 전에 이미 덮어쓴 다른 실행의 request를 식별·차단하는 증명은 아니다. +3. **현재 release 제한:** 배포 `stage2_release.json`은 `DEV_FIXTURE_RELEASE`와 `DRAFT_NOT_EXECUTABLE`이다. ingress 코드에는 `DEV_FIXTURE_REAL_RUN_FORBIDDEN` 방어가 있어 현재 release로 실제 사건 결과를 발행할 수 없다. bundle은 structural fixture 상태이며 `selected_context_refs`도 비어 있다. +4. **발행 원자성의 범위:** 비 status 파일을 원격 write/read-back한 뒤 status를 마지막에 쓰는 *논리적* barrier다. localdocs 전체 디렉터리의 원자적 rename이나 backend의 downstream barrier 소비를 입증하지 않는다. status 기록 후 예외가 생긴 경우 실패 stdout의 `FAILED_NO_BARRIER` 표현만으로 원격 status의 부재를 증명할 수도 없다. +5. **프로토콜·검증 경계:** prepare의 localdocs 응답 처리는 JSON `response.json()`에 의존하므로 서버가 SSE만 응답하는 환경과의 호환성은 확인되지 않았다. inline code receipt의 정적 parity, hash 잠금, 함수 수준 시험은 live MCP/backend 연결, Stage 1 실제 자료 완비, S2_10 전달 성공 또는 법률 내용의 타당성 검증을 대신하지 않는다. + +근거 기준: 현행 `agent_scripts/Stage_2_S2_00.yml`의 두 `parameters.code`와 `task_procedure`, `manifest/stage2_release.json`, `workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml`, `deployment/stage2_code_executor_binding.yml`, `manifest/s2_00_inline_code_receipt.json`을 대조했다. 과거 분석서나 `Stage_2_S2_00_outdated_10_01.yml`의 단일 task 구조를 현행 구조로 소급하지 않았다. diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml index b8c468d2..df39cc88 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml @@ -12,11 +12,12 @@ Agent: release_ref: Default_Agent/Stage_2_Clean/manifest/stage2_release.json workflow_contract_ref: Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml deployment_binding_ref: Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml - implementation_status: S2_00_CODE_AND_FIXTURE_OFFLINE_VERIFIED_S2_10_HYBRID_REIMPLEMENTATION_AND_RESEAL_PENDING_LIVE_ADMISSION_PENDING + implementation_status: S2_00_PREPARE_OFFLINE_VERIFIED_BACKEND_ARGUMENT_GATE_AND_SERIALIZATION_UNVERIFIED_LIVE_ADMISSION_PENDING Stages: - name: S2_00 description: >- - 단일 Code Executor 호출 안에서 C00, C05, C10, C15를 순차 실행하고 + 첫 Code Executor task에서 고정 request를 준비하고, 다음 ingress + task의 한 호출 안에서 C00, C05, C10, C15를 순차 실행한다. localdocs binary IO와 status-last 논리 배리어로 결과를 발행한다. prevs: [] nexts: [] @@ -29,6 +30,254 @@ Agent: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp tasks: + - task_name: Task_S2_00_prepare_request + description: >- + 네 외부 문자열 인자 request_id, attempt_id, stage1_run_root_ref, + stage1_deployment_root_ref를 검증하고 고정 localdocs request 경로에 + 저장·read-back한다. Backend 인자 결속 및 성공 게이트는 미검증이며 + 인자가 결속되지 않은 직접 실행은 실패로 종료한다. + mcp: code-executor + tool_name: run_code + parameters: + language: python + requirements: "httpx==0.28.1" + network: agent-network + timeout: 300 + code: |- + #!/usr/bin/env python3 + """Prepare the fixed S2_00 control request from four explicit caller values. + + The backend argument-delivery contract is not bound. Direct execution fails + closed; callers must invoke ``prepare_request`` with the four named values. + """ + + from __future__ import annotations + + import base64 + import hashlib + import json + from pathlib import PurePosixPath + import re + import sys + import unicodedata + from typing import Any, Mapping + + + REQUEST_PATH = "stage2_control/s2_00_request.json" + LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" + MCP_PROTOCOL_VERSION = "2025-03-26" + INLINE_USER_HASH = "{{__user_hash__}}" + INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" + REQUEST_KEYS = frozenset({ + "schema_version", "workflow_id", "request_id", "attempt_id", + "stage1_run_root_ref", "stage1_deployment_root_ref", + }) + ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z") + + + class PrepareError(ValueError): + def __init__(self, code: str, message: str) -> None: + super().__init__(message) + self.code = code + + + def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, ensure_ascii=False, allow_nan=False, + sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8") + + + def _relative_path(value: str, *, code: str) -> str: + if not isinstance(value, str) or not value or "\x00" in value or "\\" in value: + raise PrepareError(code, "logical path is empty or malformed") + if unicodedata.normalize("NFC", value) != value: + raise PrepareError(code, "logical path must already be NFC") + path = PurePosixPath(value) + if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts): + raise PrepareError(code, "logical path must be a contained relative path") + rendered = path.as_posix() + if rendered != value: + raise PrepareError(code, "logical path is not canonical") + return rendered + + + def build_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + ) -> bytes: + """Return the exact six-field canonical request; do not access localdocs.""" + if not isinstance(request_id, str) or ID_RE.fullmatch(request_id) is None: + raise PrepareError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(attempt_id, str) or ID_RE.fullmatch(attempt_id) is None: + raise PrepareError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + request = { + "schema_version": "stage2_s2_00_execution_request.v1", + "workflow_id": "S2_00", + "request_id": request_id, + "attempt_id": attempt_id, + "stage1_run_root_ref": _relative_path( + stage1_run_root_ref, code="STAGE1_RUN_ROOT_REF_INVALID"), + "stage1_deployment_root_ref": _relative_path( + stage1_deployment_root_ref, code="STAGE1_DEPLOYMENT_ROOT_REF_INVALID"), + } + if set(request) != REQUEST_KEYS: + raise PrepareError("RUN_REQUEST_CLOSED_SHAPE", "request field set drifted") + return canonical_json_bytes(request) + + + class LocaldocsSession: + """Small localdocs JSON-RPC session with verified binary write/read-back.""" + + def __init__(self, user_hash: str, workspace_hash: str, *, client: Any = None) -> None: + for name, value in (("user_hash", user_hash), ("workspace_hash", workspace_hash)): + if not isinstance(value, str) or re.fullmatch(r"[a-f0-9]{64}", value) is None: + raise PrepareError("CONTEXT_HASH_INVALID", f"{name} is not a SHA-256 digest") + self.user_hash = user_hash + self.workspace_hash = workspace_hash + if client is None: + try: + import httpx + except ImportError as exc: + raise PrepareError("HTTPX_UNAVAILABLE", "httpx==0.28.1 is required") from exc + client = httpx.Client(timeout=60) + self.client = client + self.headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"} + self.session_id: str | None = None + self.next_id = 10 + self.initialized = False + + def close(self) -> None: + self.client.close() + + def _post(self, body: Mapping[str, Any], expected_id: int | None) -> Mapping[str, Any] | None: + try: + response = self.client.post(LOCALDOCS_URL, json=dict(body), headers=dict(self.headers)) + response.raise_for_status() + except Exception as exc: + raise PrepareError("MCP_TRANSPORT_ERROR", "localdocs transport failed") from exc + session_id = response.headers.get("mcp-session-id") + if session_id: + if self.session_id is None and expected_id == 1: + self.session_id = session_id + elif session_id != self.session_id: + raise PrepareError("MCP_SESSION_ID_CHANGED", "localdocs session changed") + self.headers["mcp-session-id"] = session_id + if expected_id is None: + return None + try: + payload = response.json() + except Exception as exc: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response is not JSON") from exc + if not isinstance(payload, dict) or payload.get("jsonrpc") != "2.0" or payload.get("id") != expected_id: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response ID or shape mismatch") + if "error" in payload or not isinstance(payload.get("result"), dict): + raise PrepareError("MCP_TOOL_ERROR", "localdocs returned an error") + return payload["result"] + + def initialize(self) -> None: + response = self._post({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { + "protocolVersion": MCP_PROTOCOL_VERSION, "capabilities": {}, "clientInfo": { + "name": "liti-s2-00-prepare", "version": "1.0.0", + "user_id": self.user_hash, "workspace_id": self.workspace_hash, + }}}, 1) + if response is None or response.get("protocolVersion") != MCP_PROTOCOL_VERSION or self.session_id is None: + raise PrepareError("MCP_INITIALIZE_INVALID", "localdocs initialization failed") + self._post({"jsonrpc": "2.0", "method": "notifications/initialized"}, None) + self.initialized = True + + def call(self, name: str, arguments: Mapping[str, Any]) -> Mapping[str, Any]: + if not self.initialized: + raise PrepareError("MCP_NOT_INITIALIZED", "localdocs is not initialized") + message_id = self.next_id + self.next_id += 1 + result = self._post({"jsonrpc": "2.0", "id": message_id, "method": "tools/call", + "params": {"name": name, "arguments": dict(arguments)}}, message_id) + if result is None or result.get("isError") is True: + raise PrepareError("MCP_TOOL_ERROR", f"localdocs {name} failed") + return result + + def read_binary(self, logical_path: str) -> bytes: + path = _relative_path(logical_path, code="LOCALDOCS_READ_PATH_INVALID") + result = self.call("read_binary_doc", {"doc_name": path}) + content = result.get("content") + if not isinstance(content, list) or len(content) != 1 or not isinstance(content[0], dict) or content[0].get("type") != "text": + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary response") + text = content[0].get("text") + if not isinstance(text, str): + raise PrepareError("LOCALDOCS_READ_SHAPE", "missing binary envelope") + try: + envelope = json.loads(text) + if isinstance(envelope, dict) and "results" in envelope: + rows = envelope["results"] + if not isinstance(rows, list) or len(rows) != 1 or not isinstance(rows[0], dict): + raise ValueError("binary result cardinality mismatch") + inner = rows[0].get("content", rows[0].get("text")) + envelope = json.loads(inner) if isinstance(inner, str) else inner + encoded = envelope["content_base64"] + if not isinstance(encoded, str): + raise ValueError("binary content is not base64") + payload = base64.b64decode(encoded, validate=True) + size = envelope.get("byte_length", envelope.get("size")) + if size is not None and (not isinstance(size, int) or size != len(payload)): + raise ValueError("binary size mismatch") + digest = envelope.get("sha256") + if digest is not None and digest != hashlib.sha256(payload).hexdigest(): + raise ValueError("binary hash mismatch") + return payload + except (ValueError, KeyError, TypeError, base64.binascii.Error) as exc: + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary envelope") from exc + + def write_binary_verified(self, logical_path: str, payload: bytes) -> str: + path = _relative_path(logical_path, code="LOCALDOCS_WRITE_PATH_INVALID") + if path != REQUEST_PATH: + raise PrepareError("LOCALDOCS_WRITE_PATH_INVALID", "prepare may write only the fixed request path") + result = self.call("write_binary_file", { + "path": path, "content_base64": base64.b64encode(payload).decode("ascii"), "overwrite": True, + }) + if not isinstance(result.get("content"), list) or result.get("isError") is True: + raise PrepareError("LOCALDOCS_WRITE_FAILED", "localdocs did not acknowledge write") + observed = self.read_binary(path) + if observed != payload: + raise PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "request read-back differs") + return hashlib.sha256(observed).hexdigest() + + + def prepare_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + *, + localdocs: Any = None, + ) -> dict[str, Any]: + """Validate, write, read back, and close an authenticated localdocs session.""" + payload = build_request(request_id, attempt_id, stage1_run_root_ref, stage1_deployment_root_ref) + session = localdocs if localdocs is not None else LocaldocsSession(INLINE_USER_HASH, INLINE_WORKSPACE_HASH) + failure: Exception | None = None + digest: str | None = None + try: + session.initialize() + digest = session.write_binary_verified(REQUEST_PATH, payload) + except Exception as exc: + failure = exc + try: + session.close() + except Exception as exc: + if failure is None: + failure = PrepareError("LOCALDOCS_CLOSE_FAILED", "localdocs session close failed") + failure.__cause__ = exc + if failure is not None: + raise failure + return {"ok": True, "workflow_id": "S2_00", "path": REQUEST_PATH, + "request_sha256": digest} + + + if __name__ == "__main__": + sys.stdout.buffer.write(canonical_json_bytes({ + "ok": False, "error": {"code": "PREPARE_ARGUMENT_BINDING_UNVERIFIED", + "message": "four caller values must be bound by the backend"}})) + raise SystemExit(2) - task_name: Task_S2_00_deterministic_ingress description: >- 고정 request와 release를 hydration하고 S2_00 pure core를 실행한 뒤 @@ -192,7 +441,7 @@ Agent: # literal placeholders in the offline parity mirror and its unit tests. INLINE_USER_HASH = "{{__user_hash__}}" INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" INLINE_REQUEST_PATH = "stage2_control/s2_00_request.json" INLINE_STAGE2_ASSET_ROOT = "Default_Agent/Stage_2_Clean" INLINE_STAGE2_RELEASE_PATH = ( @@ -6235,13 +6484,18 @@ Agent: task_procedure: IN: nexts: - - Task_S2_00_deterministic_ingress + - Task_S2_00_prepare_request wait_until: [] + Task_S2_00_prepare_request: + nexts: + - Task_S2_00_deterministic_ingress + wait_until: + - IN Task_S2_00_deterministic_ingress: nexts: - OUT wait_until: - - IN + - Task_S2_00_prepare_request OUT: nexts: [] wait_until: diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml new file mode 100644 index 00000000..b8c468d2 --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml @@ -0,0 +1,6248 @@ +Agent: + name: Stage_2_S2_00_v2 + version: "1.2.0" + description: >- + Stage 1 Part 1-4의 고정 입력을 검증·보존·정규화하고 claim-neutral + cluster slice와 S2_10 structured-context handoff plan을 생성하는 + S2_00 deterministic ingress Agent. + metadata: + workflow_id: S2_00 + execution_class: NON-LLM-DETERMINISTIC + execution_authority: MCP_CODE_EXECUTOR_INLINE + release_ref: Default_Agent/Stage_2_Clean/manifest/stage2_release.json + workflow_contract_ref: Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml + deployment_binding_ref: Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml + implementation_status: S2_00_CODE_AND_FIXTURE_OFFLINE_VERIFIED_S2_10_HYBRID_REIMPLEMENTATION_AND_RESEAL_PENDING_LIVE_ADMISSION_PENDING + Stages: + - name: S2_00 + description: >- + 단일 Code Executor 호출 안에서 C00, C05, C10, C15를 순차 실행하고 + localdocs binary IO와 status-last 논리 배리어로 결과를 발행한다. + prevs: [] + nexts: [] + tools: + mcpServers: + localdocs: + type: streamable-http + url: http://mcp-localdocs:8012/mcp + code-executor: + type: streamable-http + url: https://code-executor.mcp.eroomai.com/mcp + tasks: + - task_name: Task_S2_00_deterministic_ingress + description: >- + 고정 request와 release를 hydration하고 S2_00 pure core를 실행한 뒤 + binding-derived root에 결과를 status-last 방식으로 발행한다. + mcp: code-executor + tool_name: run_code + parameters: + language: python + requirements: "httpx==0.28.1" + network: agent-network + timeout: 300 + code: |- + #!/usr/bin/env python3 + """Deterministic Stage 2 ingress for the S2_00 contract. + + The pure ingress core uses the Python standard library; the inline MCP adapter + adds only pinned ``httpx`` transport to the fixed localdocs endpoint. It does + not perform legal reasoning, model calls, external-network access, dynamic + imports, or runtime installation. The release, source, conservation, context, + cluster, bundle, hydration, and logical-publish contracts are re-checked here. + """ + + from __future__ import annotations + + import argparse + import base64 + import binascii + from collections import Counter, defaultdict + import contextlib + from dataclasses import dataclass + import hashlib + import io + import itertools + import json + import math + import os + from pathlib import Path, PurePosixPath + import re + import shutil + import stat + import sys + import tempfile + import unicodedata + from typing import Any, Callable, Iterable, Mapping, MutableMapping, Sequence + + + ALGORITHM_VERSION = "s2_00_ingress/1.2.0" + ALGORITHM_SEMANTIC_DIGEST = hashlib.sha256( + b"LITI-S2_00-INLINE-ALGORITHM\x00" + ALGORITHM_VERSION.encode("ascii") + ).hexdigest() + MAX_FILE_BYTES = 32 * 1024 * 1024 + MAX_RUN_BYTES = 256 * 1024 * 1024 + MAX_JSON_DEPTH = 96 + MAX_JSON_ITEMS = 1_000_000 + ROUTES = frozenset({"TO_S2_10", "TO_S2_10_WITH_ISSUES", "TO_S2_40_STATUS_ONLY"}) + RELEASE_MODE = { + "STRUCTURAL_FIXTURE": "DEV_FIXTURE_RELEASE", + "SUBSET_CANARY": "SUBSET_CANARY_RELEASE", + "PRODUCTION": "PRODUCTION_RELEASE", + } + SEMANTIC_SIGNAL_KINDS = frozenset({"canonical", "domain_signal"}) + HARD_RELATION_KINDS = frozenset( + { + "SAME_BO_ID", + "SOURCE_BO_ATTACHMENT", + "SAME_EVIDENCE_REF", + "SAME_EVENT_REF", + "EXPLICIT_CASE_RELATION", + } + ) + CANDIDATE_RELATION_KINDS = frozenset( + {"claim_precondition", "accessory_of", "incompatible_with", "EXPLICIT_DEPENDENCY"} + ) + P1_DIGEST_KEYS = { + "evidence_indexed_sha256": "evidence_indexed", + "evidence_event_candidates_sha256": "evidence_event_candidates", + "b1_gate_sha256": "b1_evidence_indexed_gate", + "b2_gate_sha256": "b2_event_candidates_gate", + "screening_sha256": "domain_screening", + "activation_manifest_sha256": "domain_activation_manifest", + "registry_index_sha256": "stage1_domain_registry_index", + } + V2_DOMAIN_IDS = frozenset({"E-01", "E-06", "E-12", "E-16", "E-18", "E-19", "E-20", "E-21"}) + CONTEXT_SCHEMA_ID = "https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json" + INGRESS_SCHEMA_ID = "https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json" + REVIEW_SCHEMA_ID = "https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json" + REQUIREMENT_CLASS_ENUM = { + "identity_backbone": "IDENTITY_BACKBONE", + "routing_profile_backbone": "ROUTING_PROFILE_BACKBONE", + "evidence_scope": "EVIDENCE_EVENT_SCOPE", + "event_scope": "EVIDENCE_EVENT_SCOPE", + "integrity_corroborator": "INTEGRITY_CORROBORATOR", + "optimization_context": "OPTIMIZATION_CONTEXT", + } + ADAPTER_IDS = { + "evidence_indexed": "S2A-EVIDENCE-V3-ENVELOPE-V1", + "evidence_event_candidates": "S2A-EVENTS-V1-ENVELOPE-V1", + "client_goal": "S2A-CLIENT-GOAL-V8-V1", + "domain_screening": "S2A-DOMAIN-SCREENING-V1", + "domain_activation_manifest": "S2A-DUAL-SG01-V1", + "b1_evidence_indexed_gate": "S2A-B1-GATE-V1", + "b2_event_candidates_gate": "S2A-B2-GATE-V1", + "stage1_part1_soft_gate_handoff": "S2A-P1-HANDOFF-FLAT-V1", + "bo": "S2A-BO-V8-LIST-V1", + "signal_manifest": "S2A-SIGNAL-ALL-V1", + "stage1_part2_review_handoff": "S2A-P2-HANDOFF-FLAT-V1", + "legal_effect_structures": "S2A-LES-CURRENT-V8-V1", + "stage1_part3_review_handoff": "S2A-P3-HANDOFF-WRAPPED-V1", + "fact_ledger_base": "S2A-FACT-LEDGER-CURRENT-V8-V1", + "fact_ledger_writer_report": "S2A-FACT-LEDGER-WRITER-REPORT-V1", + "stage1_part4_review_handoff": "S2A-P4-HANDOFF-WRAPPED-V1", + } + SG01_PROJECTION_FIELDS: tuple[str, ...] = ( + "schema_version", + "signal_id", + "status", + "registry_version", + "registry_index_sha256", + "screening_sha256", + "domain_entries", + "active_domain_ids", + "supporting_domain_ids", + "monitor_domain_ids", + "expected_runnable_domain_ids", + "required_calculation_domains", + "unrouted_material", + "conservation_gate", + "fail_open_policy", + "review_items", + "contract_guards", + ) + SG01_SET_FIELDS = frozenset( + { + "active_domain_ids", + "supporting_domain_ids", + "monitor_domain_ids", + "expected_runnable_domain_ids", + "required_calculation_domains", + } + ) + OUTPUT_SCHEMA_TARGETS: tuple[tuple[re.Pattern[str], str, str], ...] = ( + (re.compile(r"^ingress/stage1_input_manifest\.json$"), "ingress.schema.json", "#/$defs/stage1_input_manifest"), + (re.compile(r"^ingress/intake_report\.json$"), "ingress.schema.json", "#/$defs/intake_report"), + (re.compile(r"^ingress/ingress_status\.json$"), "ingress.schema.json", "#/$defs/ingress_status"), + (re.compile(r"^ingress/technical_diagnostic\.json$"), "ingress.schema.json", "#/$defs/technical_diagnostic"), + (re.compile(r"^review/issue_ledger\.base\.json$"), "review_status.schema.json", "#/$defs/issue_ledger_base"), + (re.compile(r"^context/case_context\.json$"), "context.schema.json", "#/$defs/case_context"), + (re.compile(r"^context/evidence_inventory\.json$"), "context.schema.json", "#/$defs/evidence_inventory"), + (re.compile(r"^context/object_registry\.json$"), "context.schema.json", "#/$defs/object_registry"), + (re.compile(r"^context/party_and_title_context\.json$"), "context.schema.json", "#/$defs/party_and_title_context"), + (re.compile(r"^context/slot_crosswalk\.json$"), "context.schema.json", "#/$defs/slot_crosswalk"), + (re.compile(r"^context/cluster_plan\.json$"), "context.schema.json", "#/$defs/cluster_plan"), + (re.compile(r"^context/cluster_slices/[^/]+\.json$"), "context.schema.json", "#/$defs/cluster_slice"), + (re.compile(r"^context/bundle_plan\.json$"), "context.schema.json", "#/$defs/bundle_plan"), + ) + _RAW_VALUE_UNSET = object() + + + # AgentBackend substitutes these two values in the deployed Agent YAML before + # Code Executor runs the byte-identical source. They intentionally remain + # literal placeholders in the offline parity mirror and its unit tests. + INLINE_USER_HASH = "{{__user_hash__}}" + INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" + EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + INLINE_REQUEST_PATH = "stage2_control/s2_00_request.json" + INLINE_STAGE2_ASSET_ROOT = "Default_Agent/Stage_2_Clean" + INLINE_STAGE2_RELEASE_PATH = ( + f"{INLINE_STAGE2_ASSET_ROOT}/manifest/stage2_release.json" + ) + LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" + MCP_PROTOCOL_VERSION = "2025-03-26" + INLINE_CLIENT_NAME = "liti-stage2-s2-00-inline" + INLINE_CLIENT_VERSION = "1.2.0" + INLINE_SCHEMA_MODULE_IDS = frozenset( + {"SCHEMA-INGRESS", "SCHEMA-CONTEXT", "SCHEMA-REVIEW-STATUS"} + ) + + + DEFAULT_SOURCE_CONTRACTS: tuple[dict[str, Any], ...] = ( + {"logical_input_id": "evidence_indexed", "path": "evidence_indexed.json", "criticality": "evidence_scope"}, + {"logical_input_id": "evidence_event_candidates", "path": "evidence_event_candidates.json", "criticality": "event_scope"}, + {"logical_input_id": "client_goal", "path": "client_goal.json", "criticality": "optimization_context"}, + {"logical_input_id": "domain_screening", "path": "routing/domain_screening.json", "criticality": "routing_profile_backbone"}, + {"logical_input_id": "domain_activation_manifest", "path": "routing/domain_activation_manifest.json", "criticality": "routing_profile_backbone"}, + {"logical_input_id": "b1_evidence_indexed_gate", "path": "quality_gates/B1_evidence_indexed_gate.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "b2_event_candidates_gate", "path": "quality_gates/B2_event_candidates_gate.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "stage1_part1_soft_gate_handoff", "path": "quality_gates/stage1_part1_soft_gate_handoff.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "bo", "path": "BO.json", "criticality": "identity_backbone"}, + {"logical_input_id": "signal_manifest", "path": "signals/signal_manifest.json", "criticality": "routing_profile_backbone"}, + {"logical_input_id": "stage1_part2_review_handoff", "path": "quality_gates/stage1_part2_review_handoff.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "legal_effect_structures", "path": "legal_effect_structures.json", "criticality": "routing_profile_backbone"}, + {"logical_input_id": "stage1_part3_review_handoff", "path": "quality_gates/stage1_part3_review_handoff.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "fact_ledger_base", "path": "Fact_Ledger_base.json", "criticality": "identity_backbone"}, + {"logical_input_id": "fact_ledger_writer_report", "path": "stage1_tmp/fact_ledger/fact_ledger_writer_report.json", "criticality": "integrity_corroborator"}, + {"logical_input_id": "stage1_part4_review_handoff", "path": "quality_gates/stage1_part4_review_handoff.json", "criticality": "integrity_corroborator"}, + ) + + + class IngressError(RuntimeError): + """A machine-readable deterministic ingress failure.""" + + def __init__( + self, + code: str, + message: str, + *, + logical_input_id: str | None = None, + details: Mapping[str, Any] | None = None, + ) -> None: + super().__init__(message) + self.code = code + self.logical_input_id = logical_input_id + self.details = dict(details or {}) + + def as_dict(self) -> dict[str, Any]: + result: dict[str, Any] = {"code": self.code, "message": str(self)} + if self.logical_input_id is not None: + result["logical_input_id"] = self.logical_input_id + if self.details: + result["details"] = self.details + return result + + + @dataclass(frozen=True, slots=True) + class Snapshot: + logical_input_id: str + relative_path: str + resolved_path: str + raw: bytes + raw_sha256: str + byte_length: int + device: int + inode: int + mtime_ns: int + + + def _reject_constant(value: str) -> None: + raise ValueError(f"non-finite JSON number is forbidden: {value}") + + + def _pairs_without_duplicates(pairs: Sequence[tuple[str, Any]]) -> dict[str, Any]: + result: dict[str, Any] = {} + for key, value in pairs: + if key in result: + raise ValueError(f"duplicate JSON key: {key}") + result[key] = value + return result + + + def _walk_json_limits(value: Any, *, max_depth: int, max_items: int) -> int: + count = 0 + stack: list[tuple[Any, int]] = [(value, 1)] + while stack: + current, depth = stack.pop() + if depth > max_depth: + raise IngressError("JSON_DEPTH_LIMIT", "JSON nesting depth exceeded") + if isinstance(current, dict): + count += len(current) + stack.extend((item, depth + 1) for item in current.values()) + elif isinstance(current, list): + count += len(current) + stack.extend((item, depth + 1) for item in current) + if count > max_items: + raise IngressError("JSON_ITEM_LIMIT", "JSON aggregate item limit exceeded") + return count + + + def load_json_strict( + source: Snapshot | bytes | bytearray | memoryview | str, + *, + max_depth: int = MAX_JSON_DEPTH, + max_items: int = MAX_JSON_ITEMS, + ) -> Any: + """Parse one UTF-8 JSON value, rejecting duplicate keys and non-finite numbers.""" + + if isinstance(source, Snapshot): + raw = source.raw + elif isinstance(source, str): + raw = source.encode("utf-8") + else: + raw = bytes(source) + try: + text = raw.decode("utf-8", errors="strict") + except UnicodeDecodeError as exc: + raise IngressError("INVALID_UTF8", "JSON source is not strict UTF-8") from exc + try: + value = json.loads( + text, + object_pairs_hook=_pairs_without_duplicates, + parse_constant=_reject_constant, + ) + except (json.JSONDecodeError, ValueError) as exc: + message = str(exc) + code = "DUPLICATE_JSON_KEY" if "duplicate JSON key" in message else "STRICT_JSON_PARSE_FAILED" + raise IngressError(code, message) from exc + _walk_json_limits(value, max_depth=max_depth, max_items=max_items) + return value + + + def canonical_json_bytes(value: Any) -> bytes: + """Return the project canonical parsed representation without normalizing strings.""" + + def reject_nonfinite(item: Any) -> None: + if isinstance(item, float) and not math.isfinite(item): + raise IngressError("NON_FINITE_NUMBER", "NaN and Infinity are forbidden") + if isinstance(item, dict): + for nested in item.values(): + reject_nonfinite(nested) + elif isinstance(item, (list, tuple)): + for nested in item: + reject_nonfinite(nested) + + reject_nonfinite(value) + try: + rendered = json.dumps( + value, + ensure_ascii=False, + sort_keys=True, + separators=(",", ":"), + allow_nan=False, + ) + except (TypeError, ValueError) as exc: + raise IngressError("CANONICAL_SERIALIZATION_FAILED", str(exc)) from exc + return (rendered + "\n").encode("utf-8") + + + def canonical_digest(value: Any) -> str: + return hashlib.sha256(canonical_json_bytes(value)).hexdigest() + + + class _SchemaViolation(ValueError): + """Internal deterministic JSON Schema validation failure.""" + + + def _json_equal(left: Any, right: Any) -> bool: + try: + return canonical_json_bytes(left) == canonical_json_bytes(right) + except IngressError: + return False + + + def _schema_pointer(document: Mapping[str, Any], fragment: str) -> Mapping[str, Any]: + if fragment in {"", "#"}: + return document + pointer = fragment[1:] if fragment.startswith("#") else fragment + if not pointer.startswith("/"): + raise _SchemaViolation(f"unsupported schema fragment: {fragment}") + current: Any = document + for token in pointer[1:].split("/"): + key = token.replace("~1", "/").replace("~0", "~") + if not isinstance(current, dict) or key not in current: + raise _SchemaViolation(f"unresolved schema pointer: {fragment}") + current = current[key] + if not isinstance(current, dict): + raise _SchemaViolation(f"schema pointer is not an object: {fragment}") + return current + + + def _schema_type_matches(value: Any, expected: str) -> bool: + return { + "object": isinstance(value, dict), + "array": isinstance(value, list), + "string": isinstance(value, str), + "integer": isinstance(value, int) and not isinstance(value, bool), + "number": isinstance(value, (int, float)) and not isinstance(value, bool), + "boolean": isinstance(value, bool), + "null": value is None, + }.get(expected, False) + + + def _validate_schema_node( + value: Any, + schema: Mapping[str, Any], + *, + root_schema: Mapping[str, Any], + schema_documents: Mapping[str, Mapping[str, Any]], + instance_path: str, + ) -> None: + reference = schema.get("$ref") + if isinstance(reference, str): + if reference.startswith("#"): + target_root = root_schema + fragment = reference + else: + name, separator, tail = reference.partition("#") + target_root = schema_documents.get(name) + if target_root is None: + raise _SchemaViolation(f"{instance_path}: external schema ref is not release-local: {reference}") + fragment = f"#{tail}" if separator else "#" + _validate_schema_node( + value, + _schema_pointer(target_root, fragment), + root_schema=target_root, + schema_documents=schema_documents, + instance_path=instance_path, + ) + return + if "const" in schema and not _json_equal(value, schema["const"]): + raise _SchemaViolation(f"{instance_path}: const mismatch") + if "enum" in schema and not any(_json_equal(value, candidate) for candidate in schema["enum"]): + raise _SchemaViolation(f"{instance_path}: enum mismatch") + forbidden = schema.get("not") + if isinstance(forbidden, dict) and _schema_branch_matches( + value, + forbidden, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ): + raise _SchemaViolation(f"{instance_path}: forbidden schema branch matched") + expected_type = schema.get("type") + if expected_type is not None: + alternatives = [expected_type] if isinstance(expected_type, str) else list(expected_type) + if not any(_schema_type_matches(value, item) for item in alternatives): + raise _SchemaViolation(f"{instance_path}: expected type {alternatives}") + for keyword in ("oneOf", "anyOf"): + branches = schema.get(keyword) + if isinstance(branches, list): + matches = 0 + for branch in branches: + try: + _validate_schema_node( + value, + branch, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ) + matches += 1 + except _SchemaViolation: + continue + required_matches = 1 if keyword == "oneOf" else None + if (required_matches is not None and matches != required_matches) or (keyword == "anyOf" and matches == 0): + raise _SchemaViolation(f"{instance_path}: {keyword} matched {matches} branches") + all_of = schema.get("allOf") + if isinstance(all_of, list): + for branch in all_of: + _validate_schema_node( + value, + branch, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ) + condition = schema.get("if") + if isinstance(condition, dict): + condition_matches = True + try: + _validate_schema_node( + value, + condition, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ) + except _SchemaViolation: + condition_matches = False + selected = schema.get("then" if condition_matches else "else") + if isinstance(selected, dict): + _validate_schema_node( + value, + selected, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ) + if isinstance(value, dict): + minimum_properties = schema.get("minProperties") + maximum_properties = schema.get("maxProperties") + if isinstance(minimum_properties, int) and len(value) < minimum_properties: + raise _SchemaViolation(f"{instance_path}: minProperties {minimum_properties}") + if isinstance(maximum_properties, int) and len(value) > maximum_properties: + raise _SchemaViolation(f"{instance_path}: maxProperties {maximum_properties}") + required = schema.get("required", []) + if isinstance(required, list): + missing = [key for key in required if key not in value] + if missing: + raise _SchemaViolation(f"{instance_path}: missing required keys {missing}") + properties = schema.get("properties", {}) + if isinstance(properties, dict): + pattern_properties = schema.get("patternProperties", {}) + matched_by_pattern: set[str] = set() + if isinstance(pattern_properties, dict): + for key, child_value in value.items(): + for pattern_text, child_schema in pattern_properties.items(): + if re.search(pattern_text, key) is not None and isinstance(child_schema, dict): + matched_by_pattern.add(key) + _validate_schema_node( + child_value, + child_schema, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{key}", + ) + extras = sorted(set(value) - set(properties) - matched_by_pattern) + additional = schema.get("additionalProperties") + if additional is False: + if extras: + raise _SchemaViolation(f"{instance_path}: additional properties {extras}") + elif isinstance(additional, dict): + for key in extras: + _validate_schema_node( + value[key], + additional, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{key}", + ) + for key, child_schema in properties.items(): + if key in value and isinstance(child_schema, dict): + _validate_schema_node( + value[key], + child_schema, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{key}", + ) + if isinstance(value, list): + minimum = schema.get("minItems") + maximum = schema.get("maxItems") + if isinstance(minimum, int) and len(value) < minimum: + raise _SchemaViolation(f"{instance_path}: minItems {minimum}") + if isinstance(maximum, int) and len(value) > maximum: + raise _SchemaViolation(f"{instance_path}: maxItems {maximum}") + if schema.get("uniqueItems") is True: + digests = [canonical_digest(item) for item in value] + if len(digests) != len(set(digests)): + raise _SchemaViolation(f"{instance_path}: duplicate array items") + prefix_items = schema.get("prefixItems") + if isinstance(prefix_items, list): + for index, child_schema in enumerate(prefix_items): + if index < len(value) and isinstance(child_schema, dict): + _validate_schema_node( + value[index], + child_schema, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{index}", + ) + item_schema = schema.get("items") + if item_schema is False and isinstance(prefix_items, list) and len(value) > len(prefix_items): + raise _SchemaViolation(f"{instance_path}: additional array items are forbidden") + if isinstance(item_schema, dict): + start = len(prefix_items) if isinstance(prefix_items, list) else 0 + for index, item in enumerate(value[start:], start=start): + _validate_schema_node( + item, + item_schema, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{index}", + ) + contains = schema.get("contains") + if isinstance(contains, dict): + if not any( + _schema_branch_matches( + item, + contains, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=f"{instance_path}/{index}", + ) + for index, item in enumerate(value) + ): + raise _SchemaViolation(f"{instance_path}: contains did not match") + if isinstance(value, str): + min_length = schema.get("minLength") + if isinstance(min_length, int) and len(value) < min_length: + raise _SchemaViolation(f"{instance_path}: minLength {min_length}") + max_length = schema.get("maxLength") + if isinstance(max_length, int) and len(value) > max_length: + raise _SchemaViolation(f"{instance_path}: maxLength {max_length}") + pattern = schema.get("pattern") + if isinstance(pattern, str) and re.search(pattern, value) is None: + raise _SchemaViolation(f"{instance_path}: pattern mismatch") + if isinstance(value, (int, float)) and not isinstance(value, bool): + minimum = schema.get("minimum") + if isinstance(minimum, (int, float)) and value < minimum: + raise _SchemaViolation(f"{instance_path}: minimum {minimum}") + maximum = schema.get("maximum") + if isinstance(maximum, (int, float)) and value > maximum: + raise _SchemaViolation(f"{instance_path}: maximum {maximum}") + + + def _schema_branch_matches( + value: Any, + schema: Mapping[str, Any], + *, + root_schema: Mapping[str, Any], + schema_documents: Mapping[str, Mapping[str, Any]], + instance_path: str, + ) -> bool: + try: + _validate_schema_node( + value, + schema, + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=instance_path, + ) + return True + except _SchemaViolation: + return False + + + def _load_output_schemas(asset_root: Path) -> dict[str, Mapping[str, Any]]: + documents: dict[str, Mapping[str, Any]] = {} + for name in ("ingress.schema.json", "context.schema.json", "review_status.schema.json"): + snapshot = open_bounded_snapshot(asset_root, f"schemas/{name}", logical_input_id=f"schema:{name}") + value = load_json_strict(snapshot) + if not isinstance(value, dict): + raise IngressError("OUTPUT_SCHEMA_SHAPE", f"schema is not an object: {name}") + documents[name] = value + return documents + + + def _validate_output_artifact( + relative_path: str, + value: Any, + schema_documents: Mapping[str, Mapping[str, Any]], + ) -> None: + target = next( + ( + (schema_name, schema_pointer) + for path_pattern, schema_name, schema_pointer in OUTPUT_SCHEMA_TARGETS + if path_pattern.fullmatch(relative_path) + ), + None, + ) + if target is None: + raise IngressError( + "OUTPUT_ARTIFACT_PATH_UNDECLARED", + f"no output schema target is declared for {relative_path}", + details={"path": relative_path}, + ) + schema_name, schema_pointer = target + root_schema = schema_documents[schema_name] + try: + _validate_schema_node( + value, + _schema_pointer(root_schema, schema_pointer), + root_schema=root_schema, + schema_documents=schema_documents, + instance_path=relative_path, + ) + except _SchemaViolation as exc: + raise IngressError( + "OUTPUT_SCHEMA_VALIDATION_FAILED", + str(exc), + details={"path": relative_path, "schema": schema_name, "schema_pointer": schema_pointer}, + ) from exc + + + def _safe_relative_path(relative_path: str) -> PurePosixPath: + if not isinstance(relative_path, str) or not relative_path: + raise IngressError("INVALID_SOURCE_PATH", "source path must be a non-empty string") + if "\x00" in relative_path or "\\" in relative_path: + raise IngressError("INVALID_SOURCE_PATH", "NUL and backslash are forbidden in logical paths") + logical = PurePosixPath(relative_path) + if logical.is_absolute() or any(part in {"", ".", ".."} for part in logical.parts): + raise IngressError("PATH_TRAVERSAL", f"unsafe relative path: {relative_path}") + return logical + + + def _assert_no_symlink_components(root: Path, logical: PurePosixPath) -> None: + current = root + for part in logical.parts: + current = current / part + try: + current_stat = current.lstat() + except FileNotFoundError: + return + if stat.S_ISLNK(current_stat.st_mode): + raise IngressError("SYMLINK_ESCAPE", f"symlink component rejected: {logical}") + + + def open_bounded_snapshot( + approved_root: str | os.PathLike[str], + relative_path: str, + *, + logical_input_id: str = "anonymous", + max_bytes: int = MAX_FILE_BYTES, + require_single_link: bool = True, + ) -> Snapshot: + """Read one regular file once from one descriptor and verify post-read identity.""" + + root_arg = Path(approved_root) + if root_arg.is_symlink(): + raise IngressError("SYMLINK_ROOT_REJECTED", "approved root itself may not be a symlink") + try: + root = root_arg.resolve(strict=True) + except FileNotFoundError as exc: + raise IngressError("APPROVED_ROOT_MISSING", "approved root does not exist") from exc + if not root.is_dir(): + raise IngressError("APPROVED_ROOT_NOT_DIRECTORY", "approved root must be a directory") + logical = _safe_relative_path(relative_path) + _assert_no_symlink_components(root, logical) + candidate = root.joinpath(*logical.parts) + try: + resolved = candidate.resolve(strict=True) + except FileNotFoundError as exc: + raise IngressError("SOURCE_MISSING", f"source is missing: {relative_path}", logical_input_id=logical_input_id) from exc + try: + resolved.relative_to(root) + except ValueError as exc: + raise IngressError("PATH_ESCAPE", f"resolved source escaped approved root: {relative_path}") from exc + flags = os.O_RDONLY + if hasattr(os, "O_CLOEXEC"): + flags |= os.O_CLOEXEC + if hasattr(os, "O_NOFOLLOW"): + flags |= os.O_NOFOLLOW + try: + descriptor = os.open(candidate, flags) + except OSError as exc: + raise IngressError("SOURCE_OPEN_FAILED", f"unable to open source: {relative_path}") from exc + try: + before = os.fstat(descriptor) + if not stat.S_ISREG(before.st_mode): + raise IngressError("NON_REGULAR_SOURCE", f"source is not a regular file: {relative_path}") + if require_single_link and before.st_nlink != 1: + raise IngressError("HARDLINK_POLICY_VIOLATION", f"source link count is {before.st_nlink}") + if before.st_size > max_bytes: + raise IngressError("SOURCE_SIZE_LIMIT", f"source exceeds {max_bytes} bytes") + chunks: list[bytes] = [] + total = 0 + while True: + chunk = os.read(descriptor, min(1024 * 1024, max_bytes + 1 - total)) + if not chunk: + break + chunks.append(chunk) + total += len(chunk) + if total > max_bytes: + raise IngressError("SOURCE_SIZE_LIMIT", f"source exceeds {max_bytes} bytes") + after = os.fstat(descriptor) + finally: + os.close(descriptor) + try: + path_after = candidate.stat(follow_symlinks=False) + except FileNotFoundError as exc: + raise IngressError("SOURCE_SNAPSHOT_CHANGED", "source disappeared after snapshot") from exc + identity_before = (before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns) + identity_after = (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns) + path_identity = (path_after.st_dev, path_after.st_ino, path_after.st_size, path_after.st_mtime_ns) + if identity_before != identity_after or identity_after != path_identity: + raise IngressError("SOURCE_SNAPSHOT_CHANGED", f"source changed during snapshot: {relative_path}") + raw = b"".join(chunks) + return Snapshot( + logical_input_id=logical_input_id, + relative_path=logical.as_posix(), + resolved_path=str(resolved), + raw=raw, + raw_sha256=hashlib.sha256(raw).hexdigest(), + byte_length=len(raw), + device=after.st_dev, + inode=after.st_ino, + mtime_ns=after.st_mtime_ns, + ) + + + def resolve_stage1_sources( + stage1_run_root: str | os.PathLike[str], + contract_manifest: Mapping[str, Any] | None = None, + ) -> list[dict[str, Any]]: + """Resolve only approved logical kinds; a relocation manifest cannot invent kinds.""" + + root = Path(stage1_run_root).resolve(strict=True) + if not root.is_dir(): + raise IngressError("STAGE1_ROOT_NOT_DIRECTORY", "Stage 1 run root must be a directory") + contracts = [dict(row) for row in DEFAULT_SOURCE_CONTRACTS] + overrides = dict((contract_manifest or {}).get("path_overrides", {})) + approved_ids = {row["logical_input_id"] for row in contracts} + invented = sorted(set(overrides) - approved_ids) + if invented: + raise IngressError("UNAPPROVED_LOGICAL_KIND", "relocation manifest invented logical kinds", details={"ids": invented}) + seen_paths: set[str] = set() + for row in contracts: + path = overrides.get(row["logical_input_id"], row["path"]) + safe = _safe_relative_path(path).as_posix() + if safe in seen_paths: + raise IngressError("DUPLICATE_LOGICAL_MAPPING", f"duplicate physical mapping: {safe}") + seen_paths.add(safe) + row["expected_path"] = row.pop("path") + row["observed_path"] = safe + row["resolution_source"] = ( + "RELEASE_BOUND_CONTRACT_MANIFEST" + if row["logical_input_id"] in overrides + else "DEFAULT_EXACT_PATH" + ) + return contracts + + + def load_release_lock(release_path: str | os.PathLike[str]) -> dict[str, Any]: + """Load a strict release lock without interpreting a historical status label.""" + + path = Path(release_path) + snapshot = open_bounded_snapshot(path.parent, path.name, logical_input_id="stage2_release_lock") + value = load_json_strict(snapshot) + if not isinstance(value, dict): + raise IngressError("RELEASE_LOCK_SHAPE", "release lock must be an object") + release_class = value.get("release_class") + if release_class not in set(RELEASE_MODE.values()): + raise IngressError("RELEASE_CLASS_INVALID", f"unsupported release class: {release_class}") + value = dict(value) + value["_release_raw_sha256"] = snapshot.raw_sha256 + return value + + + def _issue( + code: str, + *, + impact_scope: str = "GLOBAL", + source_refs: Sequence[str] = (), + severity: str = "ERROR", + message: str | None = None, + ) -> dict[str, Any]: + return { + "issue_code": code, + "severity": severity, + "impact_scope": impact_scope, + "scope_refs": sorted(set(source_refs)), + "source_contract_row_refs": sorted(set(source_refs)), + "reason_codes": [code], + "downstream_allowed_actions": [], + "message": message or code, + } + + + def _shape_required(value: Any, keys: Sequence[str]) -> list[str]: + if not isinstance(value, dict): + return list(keys) + return [key for key in keys if key not in value] + + + def _json_pointer_value(document: Any, pointer: str | None) -> tuple[bool, Any]: + if pointer in {None, ""}: + return (pointer == "", document) + if not isinstance(pointer, str) or not pointer.startswith("/"): + return False, None + current = document + for raw_token in pointer[1:].split("/"): + token = raw_token.replace("~1", "/").replace("~0", "~") + if isinstance(current, dict) and token in current: + current = current[token] + elif isinstance(current, list) and token.isdigit() and int(token) < len(current): + current = current[int(token)] + else: + return False, None + return True, current + + + def _release_stage1_source_rows(release_lock: Mapping[str, Any]) -> list[Mapping[str, Any]]: + rows = release_lock.get("stage1_sources") + if not isinstance(rows, list): + dependency = release_lock.get("dependency_locks", {}).get("stage1", {}) + rows = dependency.get("stage1_sources") if isinstance(dependency, dict) else None + return [row for row in rows if isinstance(row, dict)] if isinstance(rows, list) else [] + + + def _adapter_decision(release_lock: Mapping[str, Any], adapter_id: str) -> Mapping[str, Any] | None: + for row in release_lock.get("adapter_decisions", []): + if isinstance(row, dict) and row.get("adapter_id") == adapter_id and isinstance(row.get("decision"), dict): + return row["decision"] + return None + + + def _closed_adapter_shape_errors( + document: Any, + *, + logical_id: str, + adapter_id: str, + required_keys: Sequence[str], + release_lock: Mapping[str, Any], + ) -> list[str]: + errors: list[str] = [] + if required_keys: + errors.extend(f"missing root key {key}" for key in _shape_required(document, required_keys)) + decision = _adapter_decision(release_lock, adapter_id) + if decision is not None: + root_shape = decision.get("root_shape") + if root_shape == "ARRAY" and not isinstance(document, list): + errors.append("root must be an array") + elif root_shape == "OBJECT_ENVELOPE" and not isinstance(document, dict): + errors.append("root must be an object envelope") + if isinstance(document, dict): + errors.extend( + f"missing root key {key}" + for key in _shape_required(document, decision.get("required_root_fields", [])) + ) + if isinstance(document, list): + required_item_fields = decision.get("required_item_fields", decision.get("required_row_fields", [])) + if isinstance(required_item_fields, list): + for index, item in enumerate(document): + for key in _shape_required(item, required_item_fields): + errors.append(f"row {index} missing {key}") + if decision is None: + fallback_required: dict[str, tuple[str, ...]] = { + "evidence_indexed": ("schema_contract_version", "items"), + "evidence_event_candidates": ("schema_version", "items"), + "domain_activation_manifest": SG01_PROJECTION_FIELDS, + "signal_manifest": ("downstream_read_sets", "files"), + "legal_effect_structures": ("schema_version", "structure_records"), + "fact_ledger_writer_report": ( + "schema_version", + "row_count", + "gate_firings", + "domain_effect_coverage", + "calculation_readiness", + "blocked_review_items", + "conservation", + "final_sha256", + ), + } + fallback = fallback_required.get(logical_id, ()) + if fallback: + errors.extend(f"missing root key {key}" for key in _shape_required(document, fallback)) + if logical_id in {"bo", "fact_ledger_base"} and not isinstance(document, list): + errors.append("root must be an array") + return sorted(set(errors)) + + + def _schema_document_index(deployment_documents: Mapping[str, Any]) -> dict[str, Mapping[str, Any]]: + result: dict[str, Mapping[str, Any]] = {} + for path, document in deployment_documents.items(): + if not isinstance(document, dict): + continue + result[path] = document + result[PurePosixPath(path).name] = document + schema_id = document.get("$id") + if isinstance(schema_id, str): + result[schema_id] = document + return result + + + def _source_hash_index(document: Mapping[str, Any] | None) -> dict[str, str]: + result: dict[str, str] = {} + if not isinstance(document, dict): + return result + candidate_arrays: list[Any] = [] + for key in ("source_rows", "sources", "artifacts", "files", "entries"): + if isinstance(document.get(key), list): + candidate_arrays.append(document[key]) + for wrapper in ("completion_seal", "manifest", "payload", "data"): + nested = document.get(wrapper) + if isinstance(nested, dict): + for key in ("source_rows", "sources", "artifacts", "files", "entries"): + if isinstance(nested.get(key), list): + candidate_arrays.append(nested[key]) + for rows in candidate_arrays: + for row in rows: + if not isinstance(row, dict): + continue + digest = row.get("raw_sha256", row.get("sha256")) + if not isinstance(digest, str) or re.fullmatch(r"[A-Fa-f0-9]{64}", digest) is None: + continue + for key in ("logical_input_id", "path", "observed_path", "logical_id"): + identifier = row.get(key) + if isinstance(identifier, str) and identifier: + result[identifier] = digest.lower() + return result + + + def _source_producer_index(document: Mapping[str, Any] | None) -> dict[str, str]: + """Index producer evidence carried by a bounded completion/manifest row.""" + + result: dict[str, str] = {} + if not isinstance(document, dict): + return result + candidate_arrays: list[Any] = [] + for key in ("source_rows", "sources", "artifacts", "files", "entries"): + if isinstance(document.get(key), list): + candidate_arrays.append(document[key]) + for wrapper in ("completion_seal", "manifest", "payload", "data"): + nested = document.get(wrapper) + if isinstance(nested, dict): + for key in ("source_rows", "sources", "artifacts", "files", "entries"): + if isinstance(nested.get(key), list): + candidate_arrays.append(nested[key]) + for rows in candidate_arrays: + for row in rows: + if not isinstance(row, dict): + continue + producer = next( + ( + row.get(key) + for key in ("producer_id", "created_by", "writer_id", "writer", "finalized_by") + if isinstance(row.get(key), str) and row.get(key) + ), + None, + ) + if not isinstance(producer, str): + continue + for key in ("logical_input_id", "path", "observed_path", "logical_id"): + identifier = row.get(key) + if isinstance(identifier, str) and identifier: + result[identifier] = producer + return result + + + def _producer_value(document: Any) -> str | None: + if not isinstance(document, dict): + return None + for key in ("producer_id", "created_by", "writer_id", "writer", "finalized_by"): + value = document.get(key) + if isinstance(value, str) and value: + return value + for wrapper in ("metadata", "meta", "handoff", "payload"): + nested = document.get(wrapper) + if isinstance(nested, dict): + for key in ("producer_id", "created_by", "writer_id", "writer", "finalized_by"): + value = nested.get(key) + if isinstance(value, str) and value: + return value + # P3/P4 are closed one-key wrappers in the Stage 1 v8 handoff contract. + for wrapper in ( + "stage1_part3_review_handoff", + "stage1_part4_review_handoff", + ): + nested = document.get(wrapper) + if isinstance(nested, dict): + for key in ("created_by", "finalized_by"): + value = nested.get(key) + if isinstance(value, str) and value: + return value + return None + + + def _producer_matches( + observed: str, + expected: str, + alias_id: str | None, + release_lock: Mapping[str, Any], + ) -> bool: + if observed == expected: + return True + if alias_id is None: + return False + decision = _adapter_decision(release_lock, alias_id) + if decision is None or decision.get("bidirectional_match_allowed") is not True: + return False + pair = {decision.get("schema_writer_id"), decision.get("orchestration_producer_id")} + return {observed, expected} == pair + + + def _identity_ref(document: Any, pointer: str | None, logical_id: str) -> dict[str, Any]: + if pointer is None: + return {"value": None, "disposition": "NOT_APPLICABLE", "source_ref": logical_id} + found, value = _json_pointer_value(document, pointer) + if not found or value is None: + return {"value": None, "disposition": "MISSING", "source_ref": f"{logical_id}#{pointer}"} + return {"value": str(value), "disposition": "OBSERVED", "source_ref": f"{logical_id}#{pointer}"} + + + def validate_ingress_contracts( + snapshots: Mapping[str, Snapshot], + contracts: Sequence[Mapping[str, Any]], + release_lock: Mapping[str, Any], + *, + deployment_snapshots: Mapping[str, Snapshot] | None = None, + deployment_documents: Mapping[str, Any] | None = None, + completion_seal: Mapping[str, Any] | None = None, + contract_manifest: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Strictly parse sources and verify release-bound schema, producer, identity, and seal rows.""" + + documents: dict[str, Any] = {} + rows: list[dict[str, Any]] = [] + issues: list[dict[str, Any]] = [] + deployment_snapshots = deployment_snapshots or {} + deployment_documents = deployment_documents or {} + deployment_by_path = {snapshot.relative_path: snapshot for snapshot in deployment_snapshots.values()} + schema_documents = _schema_document_index(deployment_documents) + release_source_rows = _release_stage1_source_rows(release_lock) + release_ids = [str(row.get("logical_input_id")) for row in release_source_rows] + duplicate_release_ids = sorted(key for key, count in Counter(release_ids).items() if count > 1) + if duplicate_release_ids: + raise IngressError( + "RELEASE_SOURCE_CONTRACT_DUPLICATE", + "release stage1_sources contains duplicate logical_input_id rows", + details={"logical_input_ids": duplicate_release_ids}, + ) + expected_fixed = { + str(row["logical_input_id"]): str(row["path"]) + for row in DEFAULT_SOURCE_CONTRACTS + } + expected_release_ids = set(expected_fixed) | {"signal_payload_family"} + observed_release_ids = set(release_ids) + if observed_release_ids != expected_release_ids: + raise IngressError( + "RELEASE_SOURCE_CONTRACT_SET_MISMATCH", + "release stage1_sources must be the exact 16 fixed inputs plus signal_payload_family", + details={ + "missing": sorted(expected_release_ids - observed_release_ids), + "extra": sorted(observed_release_ids - expected_release_ids), + }, + ) + release_rows = {str(row.get("logical_input_id")): row for row in release_source_rows} + for logical_id, expected_path in expected_fixed.items(): + release_row = release_rows[logical_id] + if release_row.get("path") != expected_path or release_row.get("path_rule") not in {None, ""}: + raise IngressError( + "RELEASE_SOURCE_FIXED_PATH_MISMATCH", + f"fixed source path contract mismatch: {logical_id}", + ) + signal_family = release_rows["signal_payload_family"] + if ( + signal_family.get("path") is not None + or signal_family.get("path_rule") != "signals/" + or signal_family.get("adapter_id") != "S2A-SIGNAL-PAYLOAD-FAMILY-V1" + or signal_family.get("raw_hash_source") != "MANIFEST_ROW" + ): + raise IngressError( + "SIGNAL_PAYLOAD_FAMILY_CONTRACT_MISMATCH", + "signal_payload_family must use the approved manifest-expanded path contract", + ) + completion_hashes = _source_hash_index(completion_seal) + manifest_hashes = _source_hash_index(contract_manifest) + completion_producers = _source_producer_index(completion_seal) + manifest_producers = _source_producer_index(contract_manifest) + for contract in contracts: + logical_id = str(contract["logical_input_id"]) + snapshot = snapshots.get(logical_id) + release_row = release_rows.get(logical_id) + contract_missing = release_row is None + release_row = release_row or {} + alias_value = release_row.get("producer_alias", release_row.get("producer_alias_id")) + alias_id = str(alias_value) if isinstance(alias_value, str) else None + schema_ref = release_row.get("schema_ref") if isinstance(release_row.get("schema_ref"), dict) else None + row = { + "logical_input_id": logical_id, + "requirement_class": REQUIREMENT_CLASS_ENUM.get( + str(contract.get("criticality")), + "INTEGRITY_CORROBORATOR", + ), + "expected_path": contract.get("expected_path"), + "observed_path": contract.get("observed_path"), + "resolution_source": contract.get("resolution_source"), + "schema_id": schema_ref.get("$id") if schema_ref else release_row.get("schema_id"), + "schema_sha256": schema_ref.get("sha256") if schema_ref else release_row.get("schema_sha256"), + "producer_id": release_row.get("producer_id"), + "producer_alias_id": alias_id, + "adapter_id": release_row.get("adapter_id", ADAPTER_IDS.get(logical_id, "S2A-UNBOUND-V1")), + "run_identity_ref": release_row.get("run_identity_ref", {"value": None, "disposition": "MISSING", "source_ref": logical_id}), + "transaction_identity_ref": release_row.get("transaction_identity_ref", {"value": None, "disposition": "MISSING", "source_ref": logical_id}), + "scope_refs": [logical_id], + "source_contract_row_refs": [logical_id], + "reason_codes": [], + "downstream_allowed_actions": [], + "issue_codes": [], + } + if contract_missing: + code = "RELEASE_SOURCE_CONTRACT_MISSING" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + declared_path = release_row.get("path") + if isinstance(declared_path, str) and declared_path != contract.get("expected_path"): + code = "RELEASE_SOURCE_PATH_MISMATCH" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + if snapshot is None: + row.update( + { + "raw_sha256": None, + "byte_length": 0, + "parse_status": "NOT_OBSERVED", + "schema_status": "UNEVALUABLE", + "seal_status": "UNEVALUABLE", + "scope_technical_disposition": "UNAVAILABLE", + "impact_scope": "GLOBAL" if contract.get("criticality") == "identity_backbone" else "CLUSTER", + } + ) + code = "SOURCE_MISSING" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope=row["impact_scope"], source_refs=[logical_id])) + rows.append(row) + continue + row["raw_sha256"] = snapshot.raw_sha256 + row["byte_length"] = snapshot.byte_length + try: + document = load_json_strict( + snapshot, + max_depth=int(release_lock.get("limits", {}).get("max_json_depth", MAX_JSON_DEPTH)), + max_items=int(release_lock.get("limits", {}).get("max_json_items", MAX_JSON_ITEMS)), + ) + documents[logical_id] = document + row["parse_status"] = "PASS" + except IngressError as exc: + row["parse_status"] = "FAIL" + row["schema_status"] = "UNEVALUABLE" + row["seal_status"] = "UNEVALUABLE" + row["scope_technical_disposition"] = "UNAVAILABLE" + row["impact_scope"] = "GLOBAL" if contract.get("criticality") == "identity_backbone" else "CLUSTER" + row["reason_codes"].append(exc.code) + row["issue_codes"].append(exc.code) + issues.append(_issue(exc.code, impact_scope=row["impact_scope"], source_refs=[logical_id], message=str(exc))) + rows.append(row) + continue + expected_adapter = ADAPTER_IDS.get(logical_id) + if expected_adapter is not None and release_row.get("adapter_id") not in {None, expected_adapter}: + code = "ADAPTER_ID_MISMATCH" + row["schema_status"] = "FAIL" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + if schema_ref is not None: + schema_path = schema_ref.get("path") + schema_snapshot = deployment_by_path.get(schema_path) if isinstance(schema_path, str) else None + schema_document = deployment_documents.get(schema_path) if isinstance(schema_path, str) else None + expected_schema_hash = schema_ref.get("sha256") + expected_schema_id = schema_ref.get("$id") + if schema_snapshot is None or not isinstance(schema_document, dict): + schema_error = "SCHEMA_REF_NOT_IN_BOUNDED_DEPLOYMENT" + elif not isinstance(expected_schema_hash, str) or schema_snapshot.raw_sha256 != expected_schema_hash.lower(): + schema_error = "SCHEMA_HASH_MISMATCH" + elif expected_schema_id is not None and schema_document.get("$id") != expected_schema_id: + schema_error = "SCHEMA_ID_MISMATCH" + else: + schema_error = None + try: + _validate_schema_node( + document, + schema_document, + root_schema=schema_document, + schema_documents=schema_documents, + instance_path=logical_id, + ) + except _SchemaViolation as exc: + schema_error = "SOURCE_SCHEMA_VALIDATION_FAILED" + issues.append( + _issue( + schema_error, + impact_scope="CLUSTER", + source_refs=[logical_id], + message=str(exc), + ) + ) + if schema_error is not None: + row["schema_status"] = "FAIL" + row["reason_codes"].append(schema_error) + row["issue_codes"].append(schema_error) + if schema_error != "SOURCE_SCHEMA_VALIDATION_FAILED": + issues.append(_issue(schema_error, impact_scope="GLOBAL", source_refs=[logical_id])) + else: + row["schema_status"] = "PASS" + else: + adapter_errors = _closed_adapter_shape_errors( + document, + logical_id=logical_id, + adapter_id=str(row["adapter_id"]), + required_keys=release_row.get("required_keys", []), + release_lock=release_lock, + ) + if contract_missing: + row["schema_status"] = "UNEVALUABLE" + elif adapter_errors: + code = "ADAPTER_REQUIRED_KEY_MISSING" + row["schema_status"] = "FAIL" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append( + _issue( + code, + impact_scope="CLUSTER", + source_refs=[logical_id], + message="; ".join(adapter_errors), + ) + ) + else: + row["schema_status"] = "PASS" + expected_producer = release_row.get("producer_id") + document_producer = _producer_value(document) + sealed_producer = ( + completion_producers.get(logical_id) + or completion_producers.get(str(contract.get("observed_path"))) + or manifest_producers.get(logical_id) + or manifest_producers.get(str(contract.get("observed_path"))) + ) + if ( + document_producer is not None + and sealed_producer is not None + and document_producer != sealed_producer + ): + code = "PRODUCER_EVIDENCE_CONFLICT" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + observed_producer = document_producer or sealed_producer + if isinstance(expected_producer, str): + if observed_producer is None: + code = "PRODUCER_ID_UNEVALUABLE" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="CLUSTER", source_refs=[logical_id])) + elif not _producer_matches(observed_producer, expected_producer, alias_id, release_lock): + code = "PRODUCER_ID_MISMATCH" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + row["run_identity_ref"] = _identity_ref(document, release_row.get("run_identity_pointer"), logical_id) + row["transaction_identity_ref"] = _identity_ref( + document, + release_row.get("transaction_identity_pointer"), + logical_id, + ) + raw_hash_source = str(release_row.get("raw_hash_source", "NONE")) + if raw_hash_source in {"CASE_RUN_COMPLETION_SEAL", "COMPLETION_SEAL", "COMPLETION_SEAL_ROW"}: + expected_hash = completion_hashes.get(logical_id) or completion_hashes.get(str(contract.get("observed_path"))) + elif raw_hash_source in {"CONTRACT_MANIFEST", "CONTRACT_MANIFEST_ROW", "MANIFEST_ROW"}: + expected_hash = manifest_hashes.get(logical_id) or manifest_hashes.get(str(contract.get("observed_path"))) + elif raw_hash_source in {"COMPLETION_SEAL_OR_CONTRACT_MANIFEST", "SEALED_ROW"}: + expected_hash = ( + completion_hashes.get(logical_id) + or completion_hashes.get(str(contract.get("observed_path"))) + or manifest_hashes.get(logical_id) + or manifest_hashes.get(str(contract.get("observed_path"))) + ) + elif raw_hash_source in {"UNAVAILABLE_DEV", "NONE"}: + expected_hash = None + else: + expected_hash = None + code = "RAW_HASH_SOURCE_UNAPPROVED" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + if expected_hash is not None and expected_hash != snapshot.raw_sha256: + code = "RAW_HASH_MISMATCH" + row["seal_status"] = "FAIL" + row["reason_codes"].append(code) + row["issue_codes"].append(code) + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=[logical_id])) + else: + row["seal_status"] = "PASS" if expected_hash else "UNEVALUABLE" + row["scope_technical_disposition"] = ( + "UNAVAILABLE" + if contract_missing or any(code in row["issue_codes"] for code in {"RAW_HASH_MISMATCH", "SCHEMA_HASH_MISMATCH", "SCHEMA_ID_MISMATCH"}) + else "AVAILABLE" + if not row["issue_codes"] + else "AVAILABLE_WITH_ISSUES" + ) + row["impact_scope"] = "GLOBAL" if contract.get("criticality") == "identity_backbone" else "CLUSTER" + rows.append(row) + for identity_kind, field in ( + ("RUN", "run_identity_ref"), + ("TRANSACTION", "transaction_identity_ref"), + ): + observed_values = { + str(row[field]["value"]) + for row in rows + if row[field].get("disposition") == "OBSERVED" and row[field].get("value") is not None + } + if len(observed_values) > 1: + code = f"{identity_kind}_IDENTITY_CONFLICT" + issues.append(_issue(code, impact_scope="GLOBAL", source_refs=sorted(observed_values))) + for row in rows: + if row[field].get("disposition") == "OBSERVED": + row["issue_codes"] = sorted(set(row["issue_codes"] + [code])) + row["reason_codes"] = sorted(set(row["reason_codes"] + [code])) + row["scope_technical_disposition"] = "UNAVAILABLE" + return {"documents": documents, "source_contract_rows": rows, "issues": issues} + + + def _records_from_signal_document(document: Any) -> list[Any]: + if isinstance(document, list): + return list(document) + if isinstance(document, dict): + for key in ("signals", "records", "items"): + value = document.get(key) + if isinstance(value, list): + return list(value) + return [document] + return [document] + + + def _record_signal_id(record: Any) -> str | None: + if not isinstance(record, dict): + return None + value = record.get("signal_id") + if isinstance(value, str) and value: + return value + for wrapper in ("domain_activation_manifest", "payload", "data"): + nested = record.get(wrapper) + if isinstance(nested, dict) and isinstance(nested.get("signal_id"), str): + return nested["signal_id"] + return None + + + def expand_stage2_signal_all( + stage1_run_root: str | os.PathLike[str], + signal_manifest: Mapping[str, Any], + *, + max_file_bytes: int = MAX_FILE_BYTES, + max_total_bytes: int = MAX_RUN_BYTES, + signal_registry: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Expand Stage 2 ALL while separating semantic and integrity-only universes.""" + + downstream = signal_manifest.get("downstream_read_sets", {}) + stage2 = downstream.get("stage2", []) if isinstance(downstream, dict) else [] + if stage2 != ["ALL"]: + raise IngressError("SIGNAL_ALL_CONTRACT", "downstream_read_sets.stage2 must equal ['ALL']") + files = signal_manifest.get("files") + if not isinstance(files, list): + raise IngressError("SIGNAL_FILES_SHAPE", "signal manifest files must be an array") + transaction_id = str(signal_manifest.get("manifest_transaction_id", signal_manifest.get("transaction_id", "MISSING"))) + file_rows: list[dict[str, Any]] = [] + semantic_rows: list[dict[str, Any]] = [] + integrity_rows: list[dict[str, Any]] = [] + occurrences: list[dict[str, Any]] = [] + payload_snapshots: list[Snapshot] = [] + issues: list[dict[str, Any]] = [] + path_counter: Counter[str] = Counter() + parsed_documents: dict[str, Any] = {} + aggregate_bytes = 0 + registry_entries = { + str(row.get("file")): row + for row in (signal_registry or {}).get("entries", []) + if isinstance(row, dict) and isinstance(row.get("file"), str) + } + compatibility_files = { + str(path) + for path in (signal_registry or {}).get("compatibility_views", []) + if isinstance(path, str) + } + domain_envelope_schema = (signal_registry or {}).get("domain_envelope") + observed_registry_files: set[str] = set() + for index, entry in enumerate(files): + if not isinstance(entry, dict) or not isinstance(entry.get("path"), str): + raise IngressError("SIGNAL_FILE_ROW_SHAPE", f"invalid signal file row at index {index}") + relative_payload = _safe_relative_path(entry["path"]).as_posix() + if relative_payload.startswith("signals/"): + raise IngressError("SIGNAL_PATH_PREFIX_FORBIDDEN", "manifest file path must not include signals/ prefix") + physical = f"signals/{relative_payload}" + snapshot = open_bounded_snapshot( + stage1_run_root, + physical, + logical_input_id=f"signal_file:{index}", + max_bytes=max_file_bytes, + ) + document = load_json_strict(snapshot) + payload_snapshots.append(snapshot) + aggregate_bytes += snapshot.byte_length + if aggregate_bytes > max_total_bytes: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "signal ALL payloads exceed remaining run byte budget") + parsed_documents[relative_payload] = document + kind = entry.get("kind", "canonical") + if kind not in SEMANTIC_SIGNAL_KINDS | {"compatibility_view"}: + raise IngressError("SIGNAL_KIND_UNAPPROVED", f"unapproved signal file kind: {kind}") + semantic = kind in SEMANTIC_SIGNAL_KINDS + expected_hash = entry.get( + "file_sha256", entry.get("sha256", entry.get("raw_sha256")) + ) + row = { + "manifest_index": index, + "file_path": relative_payload, + "physical_path": physical, + "kind": kind, + "raw_sha256": snapshot.raw_sha256, + "byte_length": snapshot.byte_length, + "semantic": semantic, + "manifest_declared_record_count": entry.get("record_count"), + } + if expected_hash is not None and expected_hash != snapshot.raw_sha256: + row["hash_status"] = "FAIL" + issues.append(_issue("SIGNAL_FILE_HASH_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + else: + row["hash_status"] = "PASS" if expected_hash else "UNEVALUABLE" + records = _records_from_signal_document(document) + row["observed_record_count"] = len(records) + declared_count = entry.get("record_count") + if isinstance(declared_count, int) and declared_count != len(records): + row["record_count_status"] = "FAIL" + issues.append(_issue("SIGNAL_RECORD_COUNT_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + else: + row["record_count_status"] = "PASS" if isinstance(declared_count, int) else "UNEVALUABLE" + registry_row = registry_entries.get(relative_payload) + if kind == "canonical": + if signal_registry is not None and registry_row is None: + issues.append(_issue("SIGNAL_REGISTRY_COVERAGE_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + elif registry_row is not None: + observed_registry_files.add(relative_payload) + declared_schema = entry.get("schema", entry.get("schema_path")) + if declared_schema is not None and declared_schema != registry_row.get("schema"): + issues.append(_issue("SIGNAL_SCHEMA_LINEAGE_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + elif kind == "compatibility_view": + if relative_payload in registry_entries: + issues.append(_issue("SIGNAL_COMPATIBILITY_SUBSTITUTION", impact_scope="SIGNAL", source_refs=[physical])) + if signal_registry is not None and relative_payload not in compatibility_files: + issues.append(_issue("SIGNAL_REGISTRY_COVERAGE_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + elif kind == "domain_signal": + declared_schema = entry.get("schema", entry.get("schema_path")) + if signal_registry is not None and declared_schema not in {None, domain_envelope_schema}: + issues.append(_issue("SIGNAL_SCHEMA_LINEAGE_MISMATCH", impact_scope="SIGNAL", source_refs=[physical])) + file_rows.append(row) + path_counter[relative_payload] += 1 + if semantic: + semantic_rows.append(row) + for record_ordinal, record in enumerate(records): + signal_id = _record_signal_id(record) + occurrence_key = [transaction_id, relative_payload, record_ordinal, signal_id] + occurrences.append( + { + "occurrence_key": occurrence_key, + "occurrence_ref": f"SIGO-{canonical_digest(occurrence_key)[:24]}", + "manifest_transaction_id": transaction_id, + "file_path": relative_payload, + "record_ordinal": record_ordinal, + "signal_id": signal_id, + "disposition": "UNMAPPED" if signal_id is None else "UNUSED", + "binding_refs": [], + "raw_record_sha256": canonical_digest(record), + "record": record, + } + ) + else: + integrity_rows.append(row) + duplicates = sorted(path for path, count in path_counter.items() if count > 1) + if duplicates: + issues.append(_issue("SIGNAL_ALL_DUPLICATE_FILE_ROW", impact_scope="SIGNAL", source_refs=duplicates)) + manifest_counter = Counter((i, row["file_path"], row["kind"]) for i, row in enumerate(file_rows)) + partition_counter = Counter((row["manifest_index"], row["file_path"], row["kind"]) for row in semantic_rows + integrity_rows) + missing_registry_files = sorted(set(registry_entries) - observed_registry_files) if signal_registry is not None else [] + if missing_registry_files: + issues.append( + _issue( + "SIGNAL_REGISTRY_COVERAGE_MISMATCH", + impact_scope="SIGNAL", + source_refs=[f"signals/{path}" for path in missing_registry_files], + ) + ) + file_conservation = ( + manifest_counter == partition_counter + and not duplicates + and not missing_registry_files + and not any(row["hash_status"] == "FAIL" or row["record_count_status"] == "FAIL" for row in file_rows) + ) + record_counter = Counter(tuple(row["occurrence_key"]) for row in occurrences) + partitioned_record_counter = Counter( + tuple(row["occurrence_key"]) + for row in occurrences + if row["disposition"] in {"USED", "UNUSED", "UNMAPPED"} + ) + record_conservation = record_counter == partitioned_record_counter + return { + "manifest_transaction_id": transaction_id, + "ordered_file_rows": file_rows, + "semantic_file_rows": semantic_rows, + "integrity_only_file_rows": integrity_rows, + "record_occurrences": occurrences, + "used_record_occurrences": [], + "unused_record_occurrences": [row for row in occurrences if row["disposition"] == "UNUSED"], + "unmapped_record_occurrences": [row for row in occurrences if row["disposition"] == "UNMAPPED"], + "_parsed_documents_by_path": parsed_documents, + "_payload_snapshots": payload_snapshots, + "file_conservation_pass": file_conservation, + "record_conservation_pass": record_conservation, + "aggregate_payload_bytes": aggregate_bytes, + "issues": issues, + } + + + def _collect_values_for_keys(value: Any, keys: frozenset[str]) -> set[str]: + result: set[str] = set() + stack = [value] + while stack: + current = stack.pop() + if isinstance(current, dict): + for key, child in current.items(): + if key in keys: + if isinstance(child, list): + result.update(str(item) for item in child if item is not None) + elif child is not None: + result.add(str(child)) + stack.append(child) + elif isinstance(current, list): + stack.extend(current) + return result + + + def bind_signal_occurrences(signal_all: MutableMapping[str, Any], documents: Mapping[str, Any]) -> dict[str, Any]: + """Bind each semantic signal occurrence to explicit Stage 1 references without deduplication.""" + + explicit_signal_ids = _collect_values_for_keys( + documents, + frozenset({"signal_id", "signal_ids", "signal_refs", "emitted_signal_ids", "required_signal_ids"}), + ) + known_refs = { + "fact_id": _collect_values_for_keys(documents.get("fact_ledger_base"), frozenset({"fact_id"})), + "source_bo_id": _collect_values_for_keys(documents, frozenset({"BO_ID", "source_bo_id", "source_bo_ids"})), + "bo_id": _collect_values_for_keys(documents, frozenset({"BO_ID", "bo_id"})), + "structure_id": _collect_values_for_keys(documents.get("legal_effect_structures"), frozenset({"structure_id"})), + "domain_id": _collect_values_for_keys(documents, frozenset({"domain_id", "domain_ids", "active_domain_ids"})), + "evidence_id": _collect_values_for_keys(documents.get("evidence_indexed"), frozenset({"evidence_id", "id"})), + "event_id": _collect_values_for_keys(documents.get("evidence_event_candidates"), frozenset({"event_id", "id"})), + } + link_keys = { + "fact_id": ("fact_id", "fact_ids"), + "source_bo_id": ("source_bo_id", "source_bo_ids"), + "bo_id": ("bo_id", "bo_ids"), + "structure_id": ("structure_id", "structure_ids"), + "domain_id": ("domain_id", "domain_ids"), + "evidence_id": ("evidence_id", "evidence_ids"), + "event_id": ("event_id", "event_ids"), + } + for occurrence in signal_all.get("record_occurrences", []): + signal_id = occurrence.get("signal_id") + record = occurrence.get("record") + bindings: set[str] = set() + if isinstance(signal_id, str) and signal_id in explicit_signal_ids: + bindings.add(f"signal_id:{signal_id}") + for ref_kind, candidate_keys in link_keys.items(): + observed = _collect_values_for_keys(record, frozenset(candidate_keys)) + for ref in sorted(observed & known_refs[ref_kind]): + bindings.add(f"{ref_kind}:{ref}") + if not isinstance(signal_id, str) or not signal_id: + occurrence["disposition"] = "UNMAPPED" + elif bindings: + occurrence["disposition"] = "USED" + else: + occurrence["disposition"] = "UNUSED" + occurrence["binding_refs"] = sorted(bindings) + for disposition, key in ( + ("USED", "used_record_occurrences"), + ("UNUSED", "unused_record_occurrences"), + ("UNMAPPED", "unmapped_record_occurrences"), + ): + signal_all[key] = [ + row for row in signal_all.get("record_occurrences", []) if row.get("disposition") == disposition + ] + source_counter = Counter(tuple(row["occurrence_key"]) for row in signal_all.get("record_occurrences", [])) + partition_counter = Counter( + tuple(row["occurrence_key"]) + for key in ("used_record_occurrences", "unused_record_occurrences", "unmapped_record_occurrences") + for row in signal_all[key] + ) + signal_all["record_conservation_pass"] = source_counter == partition_counter + return dict(signal_all) + + + def _activation_payload(value: Mapping[str, Any]) -> Mapping[str, Any]: + for key in ("domain_activation_manifest", "activation", "payload", "data"): + nested = value.get(key) + if isinstance(nested, dict) and any(field in nested for field in SG01_PROJECTION_FIELDS): + return nested + return value + + + def verify_activation_projection( + routing_activation: Mapping[str, Any], + signal_activation: Mapping[str, Any], + *, + routing_raw_sha256: str | None = None, + signal_raw_sha256: str | None = None, + ) -> dict[str, Any]: + """Compare approved semantic SG-01 projection while retaining both raw hashes.""" + + left = _activation_payload(routing_activation) + right = _activation_payload(signal_activation) + missing_left = [field for field in SG01_PROJECTION_FIELDS if field not in left] + missing_right = [field for field in SG01_PROJECTION_FIELDS if field not in right] + if missing_left or missing_right: + raise IngressError( + "SG01_PROJECTION_SHAPE", + "both activation artifacts must expose the complete approved 17-field projection", + details={"routing_missing": missing_left, "signal_missing": missing_right}, + ) + + def project(value: Mapping[str, Any]) -> dict[str, Any]: + result: dict[str, Any] = {} + for field in SG01_PROJECTION_FIELDS: + child = value[field] + if field in SG01_SET_FIELDS: + if not isinstance(child, list): + raise IngressError("SG01_PROJECTION_SHAPE", f"{field} must be an array") + child = sorted({canonical_json_bytes(item): item for item in child}.values(), key=canonical_json_bytes) + result[field] = child + return result + + left_projection = project(left) + right_projection = project(right) + if left_projection != right_projection: + raise IngressError( + "SG01_SEMANTIC_DRIFT", + "routing activation and signal SG-01 semantic projections differ", + details={"routing_projection": left_projection, "signal_projection": right_projection}, + ) + return { + "status": "PASS", + "projection": left_projection, + "projection_sha256": canonical_digest(left_projection), + "routing_raw_sha256": routing_raw_sha256, + "signal_raw_sha256": signal_raw_sha256, + "compared_keys": list(SG01_PROJECTION_FIELDS), + } + + + def _array_rows(value: Any, preferred_keys: Sequence[str]) -> list[Any]: + if isinstance(value, list): + return list(value) + if isinstance(value, dict): + for key in preferred_keys: + candidate = value.get(key) + if isinstance(candidate, list): + return list(candidate) + return [] + + + def verify_cross_artifact_seals( + documents: Mapping[str, Any], + snapshots: Mapping[str, Snapshot], + deployment_snapshots: Mapping[str, Snapshot] | None = None, + ) -> dict[str, Any]: + """Recompute the P1 guard and current-v8 producer invariants.""" + + checks: list[dict[str, Any]] = [] + issues: list[dict[str, Any]] = [] + deployment_snapshots = deployment_snapshots or {} + p1 = documents.get("stage1_part1_soft_gate_handoff") + if isinstance(p1, dict): + digest_guard = p1.get("digest_guard") + if not isinstance(digest_guard, dict): + issues.append(_issue("P1_SEVEN_KEY_MISSING", source_refs=["stage1_part1_soft_gate_handoff"])) + digest_guard = {} + elif any(key not in digest_guard for key in P1_DIGEST_KEYS): + issues.append(_issue("P1_SEVEN_KEY_MISSING", source_refs=["stage1_part1_soft_gate_handoff#digest_guard"])) + for digest_key, logical_id in P1_DIGEST_KEYS.items(): + source = snapshots.get(logical_id) or deployment_snapshots.get(logical_id) + observed = source.raw_sha256 if source else None + expected = digest_guard.get(digest_key) + passed = expected is not None and observed is not None and expected == observed + checks.append({"check_id": f"P1:{digest_key}", "status": "PASS" if passed else "UNEVALUABLE" if source is None else "FAIL"}) + if expected is not None and observed is not None and not passed: + issues.append(_issue("P1_DIGEST_MISMATCH", source_refs=[logical_id])) + else: + issues.append(_issue("P1_HANDOFF_NOT_FLAT_OBJECT", source_refs=["stage1_part1_soft_gate_handoff"])) + p2 = documents.get("stage1_part2_review_handoff") + if p2 is not None and not isinstance(p2, dict): + issues.append(_issue("P2_HANDOFF_NOT_FLAT_OBJECT", source_refs=["stage1_part2_review_handoff"])) + for stage in (3, 4): + logical = f"stage1_part{stage}_review_handoff" + value = documents.get(logical) + if value is not None: + wrapper_present = isinstance(value, dict) and isinstance(value.get(logical), dict) + if not wrapper_present: + issues.append(_issue(f"P{stage}_WRAPPER_MISSING", source_refs=[logical])) + ledger_rows = _array_rows(documents.get("fact_ledger_base"), ("facts", "fact_ledger", "rows", "items")) + for index, row in enumerate(ledger_rows): + if not isinstance(row, dict) or "domain_effects" not in row or "calculation_requests" not in row: + issues.append(_issue("CURRENT_V8_LEDGER_EXTENSION_MISSING", impact_scope="FACT", source_refs=[f"fact_ledger_base#/{index}"])) + return {"checks": checks, "issues": issues, "passed": not any(item["severity"] == "ERROR" for item in issues)} + + + def mint_stage2_id( + namespace: str, + canonical_tuple: Any, + *, + prefix: str | None = None, + algorithm_version: str = ALGORITHM_VERSION, + collision_registry: MutableMapping[str, str] | None = None, + ) -> dict[str, str]: + """Mint a domain-separated ID and reject short-ID collisions.""" + + if not re.fullmatch(r"[A-Za-z][A-Za-z0-9_.:-]{0,127}", namespace): + raise IngressError("INVALID_ID_NAMESPACE", f"invalid namespace: {namespace}") + mint_input = { + "namespace": namespace, + "algorithm_version": algorithm_version, + "canonical_tuple": canonical_tuple, + } + full_digest = canonical_digest(mint_input) + external_prefix = prefix or namespace.upper().replace("_", "-") + external_id = f"{external_prefix}-{full_digest[:24]}" + if collision_registry is not None: + prior = collision_registry.get(external_id) + if prior is not None and prior != full_digest: + raise IngressError("MINTED_ID_COLLISION", f"collision for {external_id}") + collision_registry[external_id] = full_digest + return { + "id": external_id, + "mint_input_sha256": full_digest, + "algorithm_version": algorithm_version, + } + + + def mint_context_occurrence_id( + kind: str, + logical_artifact_id: str, + json_pointer: str, + raw_value: Any, + explicit_lineage_refs: Sequence[str], + *, + stage1_canonical_id: str | None = None, + collision_registry: MutableMapping[str, str] | None = None, + ) -> dict[str, Any]: + """Mint an occurrence/lineage context ID without fuzzy entity resolution.""" + + if kind not in {"party", "object"}: + raise IngressError("CONTEXT_KIND_INVALID", "context kind must be party or object") + raw_value_sha256 = canonical_digest(raw_value) + canonical_tuple = [ + logical_artifact_id, + json_pointer, + raw_value_sha256, + sorted(set(explicit_lineage_refs)), + ] + minted = mint_stage2_id( + f"{kind}_context_occurrence", + canonical_tuple, + prefix="PC" if kind == "party" else "OC", + collision_registry=collision_registry, + ) + source_ref = _source_ref( + logical_artifact_id, + json_pointer, + raw_value, + stage1_id=stage1_canonical_id, + ) + identity_kind = "PARTY_CONTEXT" if kind == "party" else "OBJECT_CONTEXT" + result: dict[str, Any] = { + "identity_kind": identity_kind, + f"{kind}_context_id": stage1_canonical_id or minted["id"], + f"stage1_{kind}_id": stage1_canonical_id, + "identity_disposition": ( + "PRESERVED_STAGE1_CANONICAL_ID" + if stage1_canonical_id is not None + else "IDENTITY_UNRESOLVED" + ), + "source_refs": [source_ref], + "explicit_lineage_refs": sorted(set(explicit_lineage_refs)), + "display_label_nfc": unicodedata.normalize("NFC", str(raw_value)), + "raw_display_value_sha256": raw_value_sha256, + } + if stage1_canonical_id is None: + result["derivation"] = { + "derivation_id": minted["id"], + "algorithm_version": ALGORITHM_VERSION, + "sorted_input_refs": sorted(set(explicit_lineage_refs)) or [f"{logical_artifact_id}:{json_pointer}"], + "mint_input_sha256": minted["mint_input_sha256"], + } + return result + + + def _extract_review_arrays(document: Any) -> list[Any]: + if not isinstance(document, dict): + return [] + result: list[Any] = [] + for key in ("review_items", "review_queue", "blocked_review_items", "unresolved_review_items"): + value = document.get(key) + if isinstance(value, list): + result.extend(value) + for wrapper in ( + "handoff", + "payload", + "review", + "data", + "stage1_part3_review_handoff", + "stage1_part4_review_handoff", + ): + nested = document.get(wrapper) + if isinstance(nested, dict): + result.extend(_extract_review_arrays(nested)) + return result + + + def normalize_review_items( + review_documents: Mapping[str, Any], + release_lock: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Preserve every raw review occurrence in exactly one normalized partition.""" + + stage_map = { + "stage1_part1_soft_gate_handoff": ("P1", "S2A-P1-HANDOFF-FLAT-V1"), + "stage1_part2_review_handoff": ("P2", "S2A-P2-HANDOFF-FLAT-V1"), + "stage1_part3_review_handoff": ("P3", "S2A-P3-HANDOFF-WRAPPED-V1"), + "stage1_part4_review_handoff": ("P4", "S2A-P4-HANDOFF-WRAPPED-V1"), + } + release_lock = release_lock or {} + mapping_decision = _adapter_decision(release_lock, "S2-REVIEW-MAP-V1") + mapping_rows = mapping_decision.get("mappings", []) if isinstance(mapping_decision, dict) else [] + closed_mappings: dict[tuple[str, str, str], Mapping[str, Any]] = {} + for mapping in mapping_rows: + if not isinstance(mapping, dict): + continue + key = ( + str(mapping.get("source_stage", "ANY")), + str(mapping.get("source_field_kind")), + str(mapping.get("source_value")), + ) + if key in closed_mappings: + raise IngressError("REVIEW_MAPPING_DUPLICATE", f"duplicate release review mapping: {key}") + closed_mappings[key] = mapping + adapter_issues: list[dict[str, Any]] = [] + if not closed_mappings: + adapter_issues.append(_issue("REVIEW_MAPPING_CONTRACT_MISSING", impact_scope="REVIEW_ITEM")) + collected: list[tuple[str, Any, str]] = [] + adapter_ids_seen: set[str] = set() + for logical_id in sorted(review_documents): + source_stage, adapter_id = stage_map.get(logical_id, (None, None)) + if source_stage is None or adapter_id is None: + continue + adapter_ids_seen.add(adapter_id) + decision = _adapter_decision(release_lock, adapter_id) + if decision is None: + adapter_issues.append(_issue("HANDOFF_ADAPTER_CONTRACT_MISSING", impact_scope="REVIEW_ITEM", source_refs=[logical_id])) + continue + document = review_documents[logical_id] + wrapper_pointer = decision.get("wrapper_json_pointer") + wrapper_found, wrapper = _json_pointer_value(document, wrapper_pointer) + if not wrapper_found or not isinstance(wrapper, dict): + code = "P2_HANDOFF_NOT_FLAT_OBJECT" if source_stage == "P2" else f"{source_stage}_WRAPPER_MISSING" + adapter_issues.append(_issue(code, impact_scope="REVIEW_ITEM", source_refs=[logical_id])) + continue + expected_version = decision.get("schema_version") + if wrapper.get("schema_version") != expected_version: + adapter_issues.append( + _issue( + f"{source_stage}_HANDOFF_SCHEMA_VERSION_MISMATCH", + impact_scope="REVIEW_ITEM", + source_refs=[logical_id], + ) + ) + items_found, raw_items = _json_pointer_value(wrapper, decision.get("review_items_json_pointer")) + if not items_found or not isinstance(raw_items, list): + adapter_issues.append( + _issue( + f"{source_stage}_REVIEW_ITEMS_SHAPE", + impact_scope="REVIEW_ITEM", + source_refs=[logical_id], + ) + ) + raw_items = [] + if decision.get("count_field_required") is True: + declared_count = wrapper.get("review_item_count") + if not isinstance(declared_count, int) or declared_count != len(raw_items): + adapter_issues.append( + _issue("REVIEW_CONSERVATION_FAILED", impact_scope="REVIEW_ITEM", source_refs=[logical_id]) + ) + for raw_item in raw_items: + raw_hash = canonical_digest(raw_item) + collected.append((logical_id, raw_item, raw_hash)) + grouped: dict[tuple[str, str], list[Any]] = defaultdict(list) + for logical_id, raw_item, raw_hash in collected: + grouped[(logical_id, raw_hash)].append(raw_item) + raw_occurrences: list[dict[str, Any]] = [] + normalized: list[dict[str, Any]] = [] + partition_counts = {key: 0 for key in ("SUPPORTED", "CONDITIONAL", "UNRESOLVED", "EXCLUDED", "UNMAPPED")} + for (logical_id, raw_hash), items in sorted(grouped.items()): + for duplicate_index, raw_item in enumerate(items): + raw_status = raw_item.get("status") if isinstance(raw_item, dict) else None + raw_severity = raw_item.get("severity") if isinstance(raw_item, dict) else None + source_stage, adapter_id = stage_map.get(logical_id, ("P1", "S2A-P1-HANDOFF-FLAT-V1")) + field_kind = "REVIEW_ITEM_STATUS" if raw_status is not None else "REVIEW_ITEM_SEVERITY" + source_value = str(raw_status if raw_status is not None else raw_severity) + mapping = closed_mappings.get((source_stage, field_kind, source_value)) or closed_mappings.get( + ("ANY", field_kind, source_value) + ) + partition = str(mapping.get("normalized_partition")) if mapping is not None else "UNMAPPED" + if partition not in partition_counts: + raise IngressError("REVIEW_MAPPING_PARTITION_INVALID", f"release mapping produced {partition}") + upstream_id = raw_item.get("review_id") if isinstance(raw_item, dict) else None + if upstream_id: + review_id = str(upstream_id) + minted_flag = False + else: + minted = mint_stage2_id( + "review_occurrence", + [logical_id, raw_hash, duplicate_index], + prefix="REV", + ) + review_id = minted["id"] + minted_flag = True + raw_occurrence = { + "source_stage": source_stage, + "logical_input_id": logical_id, + "canonical_raw_item_sha256": raw_hash, + "duplicate_occurrence_index": duplicate_index, + } + raw_occurrences.append(raw_occurrence) + reason_codes = ["UNMAPPED_REVIEW_STATUS"] if partition == "UNMAPPED" else [] + row = { + "review_key": { + "value": review_id, + "minted": minted_flag, + "source_stage": source_stage, + "logical_input_id": logical_id, + "canonical_raw_item_sha256": raw_hash, + "duplicate_occurrence_index": duplicate_index, + "upstream_review_id": str(upstream_id) if upstream_id is not None else None, + }, + "partition": partition, + "source_status_raw": str(raw_status) if raw_status is not None else None, + "source_severity_raw": str(raw_severity) if raw_severity is not None else None, + "source_item_raw_sha256": raw_hash, + "mapping_id": str(mapping.get("mapping_id")) if mapping is not None else f"S2-REVIEW-MAP-V1:{source_stage}:UNMAPPED", + "impact_scope": "REVIEW_ITEM", + "scope_refs": [review_id], + "source_contract_row_refs": [logical_id], + "reason_codes": reason_codes, + "downstream_allowed_actions": ["CARRY_FORWARD_TO_LAWYER_REVIEW"], + "_adapter_id": adapter_id, + } + normalized.append(row) + partition_counts[partition] += 1 + raw_counter = Counter((logical_id, raw_hash) for logical_id, _, raw_hash in collected) + normalized_counter = Counter( + (row["review_key"]["logical_input_id"], row["review_key"]["canonical_raw_item_sha256"]) + for row in normalized + ) + adapter_ids = sorted({row.pop("_adapter_id") for row in normalized} | adapter_ids_seen) + adapter_conservation_pass = not any( + item["issue_code"] == "REVIEW_CONSERVATION_FAILED" for item in adapter_issues + ) + return { + "schema_version": "stage2_review_normalization_receipt.v1", + "adapter_ids": adapter_ids or ["S2A-P1-HANDOFF-FLAT-V1"], + "mapping_table_version": "S2-REVIEW-MAP-V1", + "raw_occurrences": sorted( + raw_occurrences, + key=lambda row: ( + row["source_stage"], + row["logical_input_id"], + row["canonical_raw_item_sha256"], + row["duplicate_occurrence_index"], + ), + ), + "normalized_occurrences": sorted( + normalized, + key=lambda row: row["review_key"]["value"], + ), + "partition_counts": partition_counts, + "conservation_status": "PASS" if raw_counter == normalized_counter and adapter_conservation_pass else "FAIL", + "_issues": adapter_issues, + } + + + def check_conservation( + documents: Mapping[str, Any], + *, + signal_all: Mapping[str, Any] | None = None, + normalized_reviews: Mapping[str, Any] | None = None, + source_snapshots: Mapping[str, Snapshot] | None = None, + ) -> dict[str, Any]: + """Independently compute core set, cardinality, and multiset invariants.""" + + checks: list[dict[str, Any]] = [] + issues: list[dict[str, Any]] = [] + source_snapshots = source_snapshots or {} + + def add_check( + check_id: str, + passed: bool | None, + left: Sequence[Any] | Counter[Any] | None, + right: Sequence[Any] | Counter[Any] | None, + *, + issue_code: str, + impact_scope: str, + source_refs: Sequence[str], + details: Mapping[str, Any] | None = None, + ) -> None: + left_counter = left if isinstance(left, Counter) else Counter(left or []) + right_counter = right if isinstance(right, Counter) else Counter(right or []) + row: dict[str, Any] = { + "check_id": check_id, + "status": "UNEVALUABLE" if passed is None else "PASS" if passed else "FAIL", + "left_count": sum(left_counter.values()) if left is not None else None, + "right_count": sum(right_counter.values()) if right is not None else None, + "left_counter_digest": canonical_digest(sorted((canonical_digest(key), count) for key, count in left_counter.items())) if left is not None else None, + "right_counter_digest": canonical_digest(sorted((canonical_digest(key), count) for key, count in right_counter.items())) if right is not None else None, + } + if details: + row.update(details) + checks.append(row) + if passed is False: + issues.append(_issue(issue_code, impact_scope=impact_scope, source_refs=source_refs)) + + bo_rows = _array_rows(documents.get("bo"), ("business_objects", "BO", "rows", "items")) + ledger_rows = _array_rows(documents.get("fact_ledger_base"), ("facts", "fact_ledger", "rows", "items")) + bo_ids = [str(row["BO_ID"]) for row in bo_rows if isinstance(row, dict) and row.get("BO_ID") is not None] + source_bo_ids = [ + str(row["source_bo_id"]) + for row in ledger_rows + if isinstance(row, dict) and row.get("source_bo_id") is not None + ] + missing_bo_id_rows = [index for index, row in enumerate(bo_rows) if not isinstance(row, dict) or row.get("BO_ID") is None] + missing_source_bo_rows = [ + index for index, row in enumerate(ledger_rows) if not isinstance(row, dict) or row.get("source_bo_id") is None + ] + bo_pass = ( + not missing_bo_id_rows + and not missing_source_bo_rows + and Counter(bo_ids) == Counter(source_bo_ids) + ) + add_check( + "BO_FACT_MULTISET", + bo_pass, + bo_ids, + source_bo_ids, + issue_code="BO_FACT_CONSERVATION_FAILED", + impact_scope="FACT", + source_refs=["bo", "fact_ledger_base"], + details={ + "missing_bo_id_rows": missing_bo_id_rows, + "missing_source_bo_id_rows": missing_source_bo_rows, + "duplicate_bo_ids": sorted(key for key, count in Counter(bo_ids).items() if count > 1), + "dangling_source_bo_ids": sorted(set(source_bo_ids) - set(bo_ids)), + }, + ) + missing_fact_id_rows = [ + index for index, row in enumerate(ledger_rows) if not isinstance(row, dict) or row.get("fact_id") is None + ] + fact_ids = [str(row["fact_id"]) for row in ledger_rows if isinstance(row, dict) and row.get("fact_id") is not None] + expected_fact_ids = [f"F-{index:03d}" for index in range(1, len(ledger_rows) + 1)] + fact_pass = not missing_fact_id_rows and fact_ids == expected_fact_ids and len(fact_ids) == len(set(fact_ids)) + add_check( + "FACT_ID_SEQUENCE", + fact_pass, + fact_ids, + expected_fact_ids, + issue_code="FACT_ID_CONSERVATION_FAILED", + impact_scope="FACT", + source_refs=["fact_ledger_base"], + details={"missing_fact_id_rows": missing_fact_id_rows, "observed": fact_ids}, + ) + extension_missing = [ + index + for index, row in enumerate(ledger_rows) + if not isinstance(row, dict) + or not isinstance(row.get("domain_effects"), dict) + or not isinstance(row.get("calculation_requests"), list) + ] + add_check( + "CURRENT_V8_LEDGER_EXTENSIONS", + not extension_missing, + list(range(len(ledger_rows))), + [index for index in range(len(ledger_rows)) if index not in extension_missing], + issue_code="CURRENT_V8_LEDGER_EXTENSION_MISSING", + impact_scope="FACT", + source_refs=["fact_ledger_base"], + details={"missing_row_indices": extension_missing}, + ) + les_rows = _array_rows( + documents.get("legal_effect_structures"), + ("structures", "structure_records", "legal_effect_structures", "rows", "items"), + ) + dangling_les: list[str] = [] + les_ids: list[str] = [] + for row in les_rows: + if not isinstance(row, dict): + continue + structure_id = row.get("structure_id", row.get("legal_effect_structure_id")) + if structure_id is not None: + les_ids.append(str(structure_id)) + refs = row.get("source_bo_ids", []) + if isinstance(refs, list): + dangling_les.extend(str(ref) for ref in refs if ref not in set(bo_ids)) + duplicate_les_ids = sorted(key for key, count in Counter(les_ids).items() if count > 1) + les_pass = not dangling_les and not duplicate_les_ids and len(les_ids) == len(les_rows) + add_check( + "LES_BO_JOIN", + les_pass, + [str(row.get("structure_id", row.get("legal_effect_structure_id"))) for row in les_rows if isinstance(row, dict)], + les_ids, + issue_code="LES_BO_JOIN_FAILED", + impact_scope="CLUSTER", + source_refs=["legal_effect_structures", "bo"], + details={"dangling_refs": sorted(dangling_les), "duplicate_structure_ids": duplicate_les_ids}, + ) + declared_les_count = None + les_document = documents.get("legal_effect_structures") + if isinstance(les_document, dict): + for key in ("declared_structure_count", "structure_count", "record_count"): + if isinstance(les_document.get(key), int): + declared_les_count = int(les_document[key]) + break + declared_les_pass = None if declared_les_count is None else declared_les_count == len(les_rows) + add_check( + "LES_DECLARED_ACTUAL_COUNT", + declared_les_pass, + [None] * declared_les_count if declared_les_count is not None else None, + [None] * len(les_rows), + issue_code="LES_DECLARED_COUNT_MISMATCH", + impact_scope="CLUSTER", + source_refs=["legal_effect_structures"], + ) + actual_domain_index: dict[str, list[str]] = defaultdict(list) + actual_bo_index: dict[str, list[str]] = defaultdict(list) + ledger_structure_refs: list[tuple[str, str, str]] = [] + ledger_type_refs: list[tuple[str, str, str]] = [] + actual_structure_refs: list[tuple[str, str, str]] = [] + actual_type_refs: list[tuple[str, str, str]] = [] + route_count_errors: list[str] = [] + for row in les_rows: + if not isinstance(row, dict): + continue + structure_id = str(row.get("structure_id", row.get("legal_effect_structure_id", "MISSING"))) + domain_id = str(row.get("domain_id", "MISSING")) + type_id = str(row.get("type_id", row.get("type", "MISSING"))) + actual_domain_index[domain_id].append(structure_id) + source_ids = row.get("source_bo_ids", []) + if isinstance(source_ids, list): + for bo_id in source_ids: + actual_bo_index[str(bo_id)].append(structure_id) + actual_structure_refs.append((str(bo_id), domain_id, structure_id)) + actual_type_refs.append((str(bo_id), domain_id, type_id)) + routes = row.get("routes", []) + if isinstance(routes, list) and row.get("route_count", len(routes)) != len(routes): + route_count_errors.append(structure_id) + for row in ledger_rows: + if not isinstance(row, dict): + continue + bo_id = str(row.get("source_bo_id", "MISSING")) + effects = row.get("domain_effects", {}) + if not isinstance(effects, dict): + continue + for domain_id, effect in effects.items(): + if not isinstance(effect, dict): + continue + for structure_id in effect.get("structure_ids", []) if isinstance(effect.get("structure_ids"), list) else []: + ledger_structure_refs.append((bo_id, str(domain_id), str(structure_id))) + for type_id in effect.get("type_ids", []) if isinstance(effect.get("type_ids"), list) else []: + ledger_type_refs.append((bo_id, str(domain_id), str(type_id))) + structure_index = les_document.get("structure_index", {}) if isinstance(les_document, dict) else {} + index_present = isinstance(structure_index, dict) and bool(structure_index) + index_ok = True + if index_present: + declared_by_domain = structure_index.get("by_domain_id", {}) + declared_by_bo = structure_index.get("by_bo_id", {}) + index_ok = ( + isinstance(declared_by_domain, dict) + and isinstance(declared_by_bo, dict) + and {str(key): Counter(map(str, value)) for key, value in declared_by_domain.items() if isinstance(value, list)} + == {key: Counter(value) for key, value in actual_domain_index.items()} + and {str(key): Counter(map(str, value)) for key, value in declared_by_bo.items() if isinstance(value, list)} + == {key: Counter(value) for key, value in actual_bo_index.items()} + ) + reverse_ok = ( + (not ledger_structure_refs or Counter(ledger_structure_refs) == Counter(actual_structure_refs)) + and (not ledger_type_refs or Counter(ledger_type_refs) == Counter(actual_type_refs)) + and not route_count_errors + and index_ok + ) + add_check( + "LES_REVERSE_INDEX", + reverse_ok, + ledger_structure_refs + ledger_type_refs, + actual_structure_refs + actual_type_refs, + issue_code="LES_REVERSE_INDEX_MISMATCH", + impact_scope="CLUSTER", + source_refs=["legal_effect_structures", "fact_ledger_base"], + details={"index_present": index_present, "route_count_errors": route_count_errors}, + ) + evidence_rows = _array_rows(documents.get("evidence_indexed"), ("evidence", "evidence_items", "rows", "items")) + event_rows = _array_rows(documents.get("evidence_event_candidates"), ("events", "event_candidates", "rows", "items")) + evidence_ids = [ + str(row.get("evidence_id", row.get("id"))) + for row in evidence_rows + if isinstance(row, dict) and (row.get("evidence_id") is not None or row.get("id") is not None) + ] + event_ids = [ + str(row.get("event_id", row.get("id"))) + for row in event_rows + if isinstance(row, dict) and (row.get("event_id") is not None or row.get("id") is not None) + ] + fact_evidence_refs: list[str] = [] + fact_event_refs: list[str] = [] + event_evidence_refs: list[str] = [] + for row in ledger_rows: + if not isinstance(row, dict): + continue + evidence_values = row.get("evidence_refs", row.get("evidence_ids", [])) + event_values = row.get("event_refs", row.get("event_ids", [])) + if isinstance(evidence_values, list): + fact_evidence_refs.extend(str(ref) for ref in evidence_values) + if isinstance(event_values, list): + fact_event_refs.extend(str(ref) for ref in event_values) + for row in event_rows: + if not isinstance(row, dict): + continue + evidence_values = row.get("evidence_refs", row.get("evidence_ids", [])) + if isinstance(evidence_values, list): + event_evidence_refs.extend(str(ref) for ref in evidence_values) + evidence_failures = sorted( + set(fact_evidence_refs + event_evidence_refs) - set(evidence_ids) + ) + duplicate_evidence_ids = sorted(key for key, count in Counter(evidence_ids).items() if count > 1) + evidence_pass = not evidence_failures and not duplicate_evidence_ids + add_check( + "EVIDENCE_REFERENCE_CONSERVATION", + evidence_pass, + fact_evidence_refs + event_evidence_refs, + evidence_ids, + issue_code="EVIDENCE_REFERENCE_CONSERVATION_FAILED", + impact_scope="EVIDENCE", + source_refs=["evidence_indexed", "fact_ledger_base", "evidence_event_candidates"], + details={"dangling_refs": evidence_failures, "duplicate_evidence_ids": duplicate_evidence_ids}, + ) + event_failures = sorted(set(fact_event_refs) - set(event_ids)) + duplicate_event_ids = sorted(key for key, count in Counter(event_ids).items() if count > 1) + event_pass = not event_failures and not duplicate_event_ids + add_check( + "EVENT_REFERENCE_CONSERVATION", + event_pass, + fact_event_refs, + event_ids, + issue_code="EVENT_REFERENCE_CONSERVATION_FAILED", + impact_scope="EVIDENCE", + source_refs=["evidence_event_candidates", "fact_ledger_base"], + details={"dangling_refs": event_failures, "duplicate_event_ids": duplicate_event_ids}, + ) + disposition_rows = [row.get("disposition") for row in event_rows if isinstance(row, dict) and "disposition" in row] + b2_gate = documents.get("b2_event_candidates_gate") + declared_dispositions = None + if isinstance(b2_gate, dict): + declared_dispositions = b2_gate.get("event_disposition_counts") + if declared_dispositions is None and isinstance(b2_gate.get("summary"), dict): + declared_dispositions = b2_gate["summary"].get("event_disposition_counts") + if isinstance(declared_dispositions, dict): + disposition_expected = Counter( + {str(key): int(value) for key, value in declared_dispositions.items() if isinstance(value, int)} + ) + disposition_actual = Counter(str(value) for value in disposition_rows) + disposition_pass: bool | None = disposition_actual == disposition_expected + elif disposition_rows: + disposition_expected = Counter(str(value) for value in disposition_rows) + disposition_actual = Counter(str(value) for value in disposition_rows) + disposition_pass = all(isinstance(value, str) and value for value in disposition_rows) + else: + disposition_expected = Counter() + disposition_actual = Counter() + disposition_pass = None + add_check( + "EVENT_DISPOSITION_CONSERVATION", + disposition_pass, + disposition_actual, + disposition_expected, + issue_code="EVENT_DISPOSITION_CONSERVATION_FAILED", + impact_scope="EVIDENCE", + source_refs=["evidence_event_candidates", "b2_event_candidates_gate"], + ) + writer_report = documents.get("fact_ledger_writer_report") + if isinstance(writer_report, dict): + observed_domain_coverage = Counter( + str(domain_id) + for row in ledger_rows + if isinstance(row, dict) and isinstance(row.get("domain_effects"), dict) + for domain_id in row["domain_effects"] + ) + declared_domain_coverage = Counter( + {str(key): int(value) for key, value in writer_report.get("domain_effect_coverage", {}).items() if isinstance(value, int)} + ) + observed_readiness = Counter( + str(request.get("operand_state")) + for row in ledger_rows + if isinstance(row, dict) and isinstance(row.get("calculation_requests"), list) + for request in row["calculation_requests"] + if isinstance(request, dict) + ) + declared_readiness = Counter( + {str(key): int(value) for key, value in writer_report.get("calculation_readiness", {}).items() if isinstance(value, int)} + ) + ledger_snapshot = source_snapshots.get("fact_ledger_base") + final_hash = writer_report.get("final_sha256") + writer_pass = ( + writer_report.get("row_count") == len(ledger_rows) + and declared_domain_coverage == observed_domain_coverage + and declared_readiness == observed_readiness + and (ledger_snapshot is None or final_hash == ledger_snapshot.raw_sha256) + ) + add_check( + "FACT_LEDGER_WRITER_REPORT_CONNECTION", + writer_pass, + [len(ledger_rows), observed_domain_coverage, observed_readiness, ledger_snapshot.raw_sha256 if ledger_snapshot else None], + [writer_report.get("row_count"), declared_domain_coverage, declared_readiness, final_hash], + issue_code="FACT_LEDGER_WRITER_REPORT_MISMATCH", + impact_scope="FACT", + source_refs=["fact_ledger_base", "fact_ledger_writer_report"], + ) + else: + add_check( + "FACT_LEDGER_WRITER_REPORT_CONNECTION", + None, + None, + None, + issue_code="FACT_LEDGER_WRITER_REPORT_MISMATCH", + impact_scope="FACT", + source_refs=["fact_ledger_base", "fact_ledger_writer_report"], + ) + if signal_all is not None: + file_pass = bool(signal_all.get("file_conservation_pass")) + record_pass = bool(signal_all.get("record_conservation_pass")) + checks.append({"check_id": "SIGNAL_FILE_ROW_CONSERVATION", "status": "PASS" if file_pass else "FAIL"}) + checks.append({"check_id": "SIGNAL_RECORD_OCCURRENCE_CONSERVATION", "status": "PASS" if record_pass else "FAIL"}) + issues.extend(signal_all.get("issues", [])) + if not file_pass: + issues.append(_issue("SIGNAL_FILE_CONSERVATION_FAILED", impact_scope="SIGNAL")) + if not record_pass: + issues.append(_issue("SIGNAL_RECORD_CONSERVATION_FAILED", impact_scope="SIGNAL")) + if normalized_reviews is not None: + review_pass = normalized_reviews.get("conservation_status") == "PASS" + checks.append({"check_id": "REVIEW_OCCURRENCE_CONSERVATION", "status": "PASS" if review_pass else "FAIL"}) + if not review_pass: + issues.append(_issue("REVIEW_CONSERVATION_FAILED", impact_scope="REVIEW_ITEM")) + issues.extend(normalized_reviews.get("_issues", [])) + return {"checks": checks, "issues": issues, "passed": not any(check["status"] == "FAIL" for check in checks)} + + + def _source_ref( + logical_id: str, + pointer: str, + raw_value: Any = _RAW_VALUE_UNSET, + *, + stage1_id: str | None = None, + ) -> dict[str, Any]: + """Build a truthful RFC 6901 provenance row without pointer narrowing.""" + + row: dict[str, Any] = { + "logical_artifact_id": logical_id, + "json_pointer": pointer, + "raw_value_sha256": canonical_digest( + [logical_id, pointer] + if raw_value is _RAW_VALUE_UNSET + else raw_value + ), + "source_contract_row_ref": logical_id, + } + if stage1_id is not None: + row["stage1_id"] = stage1_id + return row + + + def _dedupe_source_refs(rows: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]: + by_digest = {canonical_digest(dict(row)): dict(row) for row in rows} + return [by_digest[key] for key in sorted(by_digest)] + + + def _coerce_source_ref(value: Mapping[str, Any] | str) -> dict[str, Any]: + if isinstance(value, dict) and { + "logical_artifact_id", + "json_pointer", + "raw_value_sha256", + }.issubset(value): + return dict(value) + text = str(value) + if "#" in text: + logical_id, pointer = text.split("#", 1) + else: + logical_id, pointer = text, "" + if pointer and not pointer.startswith("/"): + pointer = "/" + pointer + return _source_ref(logical_id or "unknown", pointer, text) + + + def _artifact_header( + schema_id: str = CONTEXT_SCHEMA_ID, + *, + schema_sha256: str = "0" * 64, + run_id: str = "STRUCTURAL-FIXTURE", + input_set_digest: str = "0" * 64, + stage2_release_digest: str = "0" * 64, + algorithm_digest: str = "0" * 64, + release_class: str = "DEV_FIXTURE_RELEASE", + ) -> dict[str, Any]: + return { + "schema_id": schema_id, + "schema_sha256": schema_sha256, + "schema_version": "stage2_s2_00_context.v2", + "producer_id": "S2_00", + "run_id": run_id, + "input_set_digest": input_set_digest, + "stage2_release_digest": stage2_release_digest, + "algorithm_digest": algorithm_digest, + "release_class": release_class, + } + + + def _derivation( + namespace: str, + input_refs: Sequence[str], + payload: Any, + ) -> dict[str, Any]: + sorted_refs = sorted(set(str(item) for item in input_refs)) or ["S2_00:EMPTY_INPUT_SET"] + minted = mint_stage2_id(namespace, [sorted_refs, payload], prefix="DRV") + return { + "derivation_id": minted["id"], + "algorithm_version": ALGORITHM_VERSION, + "sorted_input_refs": sorted_refs, + "mint_input_sha256": minted["mint_input_sha256"], + } + + + def build_case_context( + documents: Mapping[str, Any], + *, + run_binding_digest: str, + issues: Sequence[Mapping[str, Any]] = (), + artifact_header: Mapping[str, Any] | None = None, + signal_all: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + routing = documents.get("domain_activation_manifest") + routing_payload = _activation_payload(routing) if isinstance(routing, dict) else {} + active = routing_payload.get("active_domain_ids", []) + expected = routing_payload.get("expected_runnable_domain_ids", []) + bo_rows = _array_rows(documents.get("bo"), ("business_objects", "BO", "rows", "items")) + ledger_rows = _array_rows(documents.get("fact_ledger_base"), ("facts", "fact_ledger", "rows", "items")) + les_rows = _array_rows(documents.get("legal_effect_structures"), ("structures", "structure_records", "legal_effect_structures", "rows", "items")) + bo_ids = sorted( + str(row["BO_ID"]) + for row in bo_rows + if isinstance(row, dict) and row.get("BO_ID") is not None + ) + structure_ids = sorted( + str(row.get("structure_id", row.get("legal_effect_structure_id"))) + for row in les_rows + if isinstance(row, dict) and (row.get("structure_id") is not None or row.get("legal_effect_structure_id") is not None) + ) + structures_by_bo: dict[str, list[str]] = defaultdict(list) + for row in les_rows: + if not isinstance(row, dict): + continue + structure_id = row.get("structure_id", row.get("legal_effect_structure_id")) + for bo_id in row.get("source_bo_ids", []) if isinstance(row.get("source_bo_ids"), list) else []: + if structure_id is not None: + structures_by_bo[str(bo_id)].append(str(structure_id)) + fact_contexts: list[dict[str, Any]] = [] + for index, row in enumerate(ledger_rows): + if not isinstance(row, dict): + continue + if row.get("fact_id") is None or row.get("source_bo_id") is None: + continue + fact_id = str(row["fact_id"]) + source_bo_id = str(row.get("source_bo_id", "MISSING")) + evidence_refs = row.get("evidence_refs", row.get("evidence_ids", [])) + event_refs = row.get("event_refs", row.get("event_ids", [])) + calculation_requests = row.get("calculation_requests", []) + law_version_refs = row.get("law_version_refs", []) + signal_occurrence_refs = sorted( + str(occurrence.get("occurrence_ref")) + for occurrence in (signal_all or {}).get("record_occurrences", []) + if occurrence.get("disposition") == "USED" + and ( + f"fact_id:{fact_id}" in occurrence.get("binding_refs", []) + or f"source_bo_id:{source_bo_id}" in occurrence.get("binding_refs", []) + or f"bo_id:{source_bo_id}" in occurrence.get("binding_refs", []) + ) + ) + fact_contexts.append( + { + "fact_id": fact_id, + "source_bo_id": source_bo_id, + "party_context_ids": [], + "object_context_ids": [], + "structure_refs": sorted(set(structures_by_bo.get(source_bo_id, []))), + "signal_occurrence_refs": signal_occurrence_refs, + "calculation_request_refs": sorted( + canonical_digest(value) + for value in (calculation_requests if isinstance(calculation_requests, list) else []) + ), + "law_version_refs": sorted(str(value) for value in law_version_refs) if isinstance(law_version_refs, list) else [], + "evidence_refs": sorted(str(value) for value in evidence_refs) if isinstance(evidence_refs, list) else [], + "event_refs": sorted(str(value) for value in event_refs) if isinstance(event_refs, list) else [], + "review_keys": [], + "source_refs": [_source_ref("fact_ledger_base", f"/rows/{index}", row, stage1_id=fact_id)], + } + ) + source_refs = _dedupe_source_refs( + [ + _source_ref("bo", "", documents.get("bo")), + _source_ref("fact_ledger_base", "", documents.get("fact_ledger_base")), + _source_ref("legal_effect_structures", "", documents.get("legal_effect_structures")), + _source_ref("domain_activation_manifest", "", documents.get("domain_activation_manifest")), + _source_ref("client_goal", "", documents.get("client_goal")), + ] + ) + minted = mint_stage2_id( + "case_context", + [run_binding_digest, [row["fact_id"] for row in fact_contexts], bo_ids, structure_ids], + prefix="CC", + ) + unavailable_scope_refs = sorted( + { + str(scope_ref) + for item in issues + if item.get("issue_code") + for scope_ref in item.get("scope_refs", []) + } + ) + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "case_context_id": minted["id"], + "facts": sorted(fact_contexts, key=lambda row: row["fact_id"]), + "bo_ids": bo_ids, + "structure_ids": structure_ids, + "active_domain_ids": sorted(set(str(value) for value in active)) if isinstance(active, list) else [], + "expected_runnable_domain_ids": sorted(set(str(value) for value in expected)) if isinstance(expected, list) else [], + "unavailable_scope_refs": unavailable_scope_refs, + "source_refs": source_refs, + "derivation": _derivation("case_context_derivation", [f"fact:{row['fact_id']}" for row in fact_contexts], minted["mint_input_sha256"]), + } + + + def build_evidence_inventory( + documents: Mapping[str, Any], + *, + run_binding_digest: str, + artifact_header: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + evidence_rows = _array_rows(documents.get("evidence_indexed"), ("evidence", "evidence_items", "rows", "items")) + event_rows = _array_rows(documents.get("evidence_event_candidates"), ("events", "event_candidates", "rows", "items")) + ledger_rows = _array_rows(documents.get("fact_ledger_base"), ("facts", "fact_ledger", "rows", "items")) + event_by_evidence: dict[str, set[str]] = defaultdict(set) + for index, row in enumerate(event_rows): + if not isinstance(row, dict): + continue + event_id = str(row.get("event_id", f"EVENT-OCCURRENCE-{index}")) + refs = row.get("evidence_refs", row.get("evidence_ids", [])) + if isinstance(refs, list): + for ref in refs: + event_by_evidence[str(ref)].add(event_id) + facts_by_evidence: dict[str, set[str]] = defaultdict(set) + for row in ledger_rows: + if not isinstance(row, dict) or row.get("fact_id") is None: + continue + refs = row.get("evidence_refs", row.get("evidence_ids", [])) + if isinstance(refs, list): + for ref in refs: + facts_by_evidence[str(ref)].add(str(row["fact_id"])) + items: list[dict[str, Any]] = [] + for index, row in enumerate(evidence_rows): + if not isinstance(row, dict): + continue + evidence_id = str(row.get("evidence_id", row.get("id", f"EVIDENCE-OCCURRENCE-{index}"))) + items.append( + { + "evidence_id": evidence_id, + "event_ids": sorted(event_by_evidence.get(evidence_id, set())), + "linked_fact_ids": sorted(facts_by_evidence.get(evidence_id, set())), + "technical_disposition": "AVAILABLE", + "source_refs": [_source_ref("evidence_indexed", f"/items/{index}", row, stage1_id=evidence_id)], + } + ) + source_refs = _dedupe_source_refs( + [ + _source_ref("evidence_indexed", "", documents.get("evidence_indexed")), + _source_ref("evidence_event_candidates", "", documents.get("evidence_event_candidates")), + _source_ref("fact_ledger_base", "", documents.get("fact_ledger_base")), + ] + ) + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "items": sorted(items, key=lambda row: row["evidence_id"]), + "source_refs": source_refs, + "derivation": _derivation("evidence_inventory_derivation", [f"evidence:{row['evidence_id']}" for row in items], run_binding_digest), + } + + + def _candidate_values(row: Mapping[str, Any], keys: Sequence[str]) -> list[tuple[str, Any]]: + result: list[tuple[str, Any]] = [] + for key in keys: + value = row.get(key) + if value is None: + continue + if isinstance(value, list): + result.extend((f"/{key}/{index}", item) for index, item in enumerate(value)) + else: + result.append((f"/{key}", value)) + return result + + + def build_object_registry( + documents: Mapping[str, Any], + *, + run_binding_digest: str, + artifact_header: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + bo_rows = _array_rows(documents.get("bo"), ("business_objects", "BO", "rows", "items")) + objects: list[dict[str, Any]] = [] + collision_registry: dict[str, str] = {} + for index, row in enumerate(bo_rows): + if not isinstance(row, dict): + continue + explicit_bo = row.get("BO_ID") + for pointer, value in _candidate_values(row, ("object", "objects", "asset", "subject_matter")): + stage1_object_id = value.get("object_id") if isinstance(value, dict) else None + context = mint_context_occurrence_id( + "object", + "bo", + f"/{index}{pointer}", + value, + [str(explicit_bo)] if explicit_bo is not None else [], + stage1_canonical_id=str(stage1_object_id) if stage1_object_id is not None else None, + collision_registry=collision_registry, + ) + objects.append(context) + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "objects": sorted(objects, key=lambda row: row["object_context_id"]), + "source_refs": [_source_ref("bo", "", documents.get("bo"))], + "derivation": _derivation("object_registry_derivation", [row["object_context_id"] for row in objects], run_binding_digest), + } + + + def build_party_and_title_context( + documents: Mapping[str, Any], + *, + run_binding_digest: str, + artifact_header: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + bo_rows = _array_rows(documents.get("bo"), ("business_objects", "BO", "rows", "items")) + parties: list[dict[str, Any]] = [] + collision_registry: dict[str, str] = {} + for index, row in enumerate(bo_rows): + if not isinstance(row, dict): + continue + explicit_bo = row.get("BO_ID") + for pointer, value in _candidate_values(row, ("party", "parties", "creditor", "debtor", "counterparty")): + stage1_party_id = value.get("party_id") if isinstance(value, dict) else None + identity = mint_context_occurrence_id( + "party", + "bo", + f"/{index}{pointer}", + value, + [str(explicit_bo)] if explicit_bo is not None else [], + stage1_canonical_id=str(stage1_party_id) if stage1_party_id is not None else None, + collision_registry=collision_registry, + ) + source_refs = identity["source_refs"] + parties.append( + { + "party_identity": identity, + "party_title": value.get("party_title") if isinstance(value, dict) else None, + "defendant_role": value.get("defendant_role") if isinstance(value, dict) else None, + "liability_context": value.get("liability_context") if isinstance(value, dict) else None, + "client_instruction": value.get("client_instruction") if isinstance(value, dict) else None, + "recovery_information": value.get("recovery_information") if isinstance(value, dict) else None, + "source_refs": source_refs, + } + ) + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "parties": sorted(parties, key=lambda row: row["party_identity"]["party_context_id"]), + "source_refs": [_source_ref("bo", "", documents.get("bo"))], + "derivation": _derivation( + "party_title_derivation", + [row["party_identity"]["party_context_id"] for row in parties], + run_binding_digest, + ), + } + + + def build_slot_crosswalk( + documents: Mapping[str, Any], + domain_configs: Mapping[str, Any] | None = None, + *, + run_binding_digest: str, + artifact_header: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + domain_configs = domain_configs or {} + rows: list[dict[str, Any]] = [] + for domain_id in sorted(domain_configs): + config = domain_configs[domain_id] + adapter_id = "S2A-DOMAIN-CONFIG-V2" if domain_id in V2_DOMAIN_IDS else "S2A-DOMAIN-CONFIG-V1" + if not isinstance(config, dict): + continue + for slot_kind, key in ( + ("ELEMENT", "element_slots"), + ("OPPOSING_FACT", "opposing_fact_slots"), + ("DEFENSE", "defense_map"), + ): + values = config.get(key, []) + if isinstance(values, dict): + values = [{"slot_id": item_key, "value": item_value} for item_key, item_value in values.items()] + if not isinstance(values, list): + continue + for index, value in enumerate(values): + rows.append( + { + "domain_id": domain_id, + "slot_ref": str(value.get("slot_id", value.get("id", f"{domain_id}:{key}:{index}"))) if isinstance(value, dict) else f"{domain_id}:{key}:{index}", + "slot_kind": slot_kind, + "fact_ids": [], + "evidence_refs": [], + "evaluation_status": "UNEVALUABLE", + "proposed_new_slot": False, + "source_refs": [_source_ref(f"domain_config:{domain_id}", f"/{key}/{index}", value)], + "_adapter_id": adapter_id, + } + ) + adapter_ids = sorted({row.pop("_adapter_id") for row in rows}) + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "domain_config_adapter_ids": adapter_ids, + "rows": sorted(rows, key=lambda row: (row["domain_id"], row["slot_kind"], row["slot_ref"])), + "rebuttal_slot_synthesis_count": 0, + "source_refs": _dedupe_source_refs( + [_source_ref("fact_ledger_base", "", documents.get("fact_ledger_base"))] + + [_source_ref(f"domain_config:{key}", "", domain_configs[key]) for key in sorted(domain_configs)] + ), + "derivation": _derivation("slot_crosswalk_derivation", [row["slot_ref"] for row in rows], run_binding_digest), + } + + + def _tarjan_scc(nodes: Sequence[str], edges: Sequence[tuple[str, str]]) -> list[list[str]]: + adjacency: dict[str, list[str]] = {node: [] for node in nodes} + for source, target in edges: + adjacency.setdefault(source, []).append(target) + adjacency.setdefault(target, []) + for value in adjacency.values(): + value.sort() + index = 0 + stack: list[str] = [] + on_stack: set[str] = set() + indices: dict[str, int] = {} + lowlink: dict[str, int] = {} + components: list[list[str]] = [] + + def visit(node: str) -> None: + nonlocal index + indices[node] = index + lowlink[node] = index + index += 1 + stack.append(node) + on_stack.add(node) + for neighbor in adjacency[node]: + if neighbor not in indices: + visit(neighbor) + lowlink[node] = min(lowlink[node], lowlink[neighbor]) + elif neighbor in on_stack: + lowlink[node] = min(lowlink[node], indices[neighbor]) + if lowlink[node] == indices[node]: + component: list[str] = [] + while True: + member = stack.pop() + on_stack.remove(member) + component.append(member) + if member == node: + break + components.append(sorted(component)) + + for node in sorted(adjacency): + if node not in indices: + visit(node) + return sorted(components, key=lambda component: component[0]) + + + def compile_cluster_plan( + members: Sequence[Mapping[str, Any]], + relations: Sequence[Mapping[str, Any]], + *, + algorithm_version: str = ALGORITHM_VERSION, + artifact_header: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Compile claim-neutral clusters using only explicit hard relations.""" + + by_id = {str(row["member_id"]): dict(row) for row in members} + if len(by_id) != len(members): + raise IngressError("DUPLICATE_CLUSTER_MEMBER_ID", "cluster member IDs must be unique") + parent = {member_id: member_id for member_id in by_id} + + def find(value: str) -> str: + while parent[value] != value: + parent[value] = parent[parent[value]] + value = parent[value] + return value + + def union(left: str, right: str) -> None: + a, b = find(left), find(right) + if a != b: + parent[max(a, b)] = min(a, b) + + normalized_relations: list[dict[str, Any]] = [] + relation_key_map = { + "SAME_BO_ID": ("EXPLICIT_SOURCE_RELATION", "SAME_BO_ID", True), + "SOURCE_BO_ATTACHMENT": ("EXPLICIT_SOURCE_RELATION", "LES_SOURCE_BO_ID", True), + "SAME_EVIDENCE_REF": ("EXPLICIT_SOURCE_RELATION", "SAME_EVIDENCE_REF", True), + "SAME_EVENT_REF": ("EXPLICIT_SOURCE_RELATION", "SAME_EVENT_REF", True), + "EXPLICIT_CASE_RELATION": ("EXPLICIT_SOURCE_RELATION", "APPROVED_EXPLICIT_CASE_RELATION", True), + "claim_precondition": ("CANDIDATE_RELATION", "CLAIM_PRECONDITION_CANDIDATE", False), + "accessory_of": ("CANDIDATE_RELATION", "ACCESSORY_OF_CANDIDATE", False), + "incompatible_with": ("CANDIDATE_RELATION", "INCOMPATIBLE_WITH_CANDIDATE", False), + "EXPLICIT_DEPENDENCY": ("CANDIDATE_RELATION", "CLAIM_PRECONDITION_CANDIDATE", False), + } + for relation in relations: + source = str(relation.get("source_member_id")) + target = str(relation.get("target_member_id")) + kind = str(relation.get("relation_kind")) + if source not in by_id or target not in by_id: + raise IngressError("DANGLING_CLUSTER_RELATION", f"relation references unknown member: {source}->{target}") + explicit_source_refs = relation.get("source_refs") + if not isinstance(explicit_source_refs, list) or not explicit_source_refs: + raise IngressError("RELATION_SOURCE_REF_MISSING", "every cluster relation needs explicit source refs") + edge_class, relation_key, hard_join_allowed = relation_key_map.get( + kind, + ("CANDIDATE_RELATION", "CLAIM_PRECONDITION_CANDIDATE", False), + ) + relation_source_refs = _dedupe_source_refs( + _coerce_source_ref(item) for item in explicit_source_refs + ) + edge_mint = mint_stage2_id( + "cluster_edge", + [source, target, kind, relation_source_refs], + prefix="EDGE", + ) + normalized = { + "source_member_id": source, + "target_member_id": target, + "source_relation_kind": kind, + "edge_id": edge_mint["id"], + "edge_class": edge_class, + "relation_key": relation_key, + "hard_join_allowed": hard_join_allowed, + "source_refs": relation_source_refs, + } + normalized_relations.append(normalized) + if hard_join_allowed and kind in HARD_RELATION_KINDS: + union(source, target) + groups: dict[str, list[str]] = defaultdict(list) + for member_id in sorted(by_id): + groups[find(member_id)].append(member_id) + collision_registry: dict[str, str] = {} + cluster_build_rows: list[dict[str, Any]] = [] + member_to_cluster: dict[str, str] = {} + for member_ids in sorted((sorted(value) for value in groups.values()), key=lambda value: value[0]): + source_refs = _dedupe_source_refs( + _coerce_source_ref(ref) + for member_id in member_ids + for ref in by_id[member_id].get("source_refs", []) + ) + relation_keys = sorted( + canonical_digest(relation) + for relation in normalized_relations + if relation["source_member_id"] in member_ids and relation["target_member_id"] in member_ids + ) + minted = mint_stage2_id( + "cluster", + [sorted(member_ids), source_refs, relation_keys], + prefix="CL", + algorithm_version=algorithm_version, + collision_registry=collision_registry, + ) + executable = bool(source_refs) and all( + by_id[member_id].get("scope_technical_disposition", "AVAILABLE") != "UNAVAILABLE" + and not by_id[member_id].get("residual_review_only", False) + for member_id in member_ids + ) + cluster = { + "cluster_id": minted["id"], + "mint_input_sha256": minted["mint_input_sha256"], + "member_ids": member_ids, + "source_refs": source_refs, + "cluster_status": "EXECUTABLE" if executable else "RESIDUAL_REVIEW_ONLY", + } + cluster_build_rows.append(cluster) + for member_id in member_ids: + member_to_cluster[member_id] = minted["id"] + cluster_edges: list[dict[str, Any]] = [] + edge_pairs: set[tuple[str, str]] = set() + for relation in normalized_relations: + source_cluster = member_to_cluster[relation["source_member_id"]] + target_cluster = member_to_cluster[relation["target_member_id"]] + if source_cluster == target_cluster: + continue + if relation["source_relation_kind"] not in CANDIDATE_RELATION_KINDS: + continue + edge = { + "source_cluster_id": source_cluster, + "target_cluster_id": target_cluster, + "edge_id": relation["edge_id"], + "edge_class": relation["edge_class"], + "relation_key": relation["relation_key"], + "hard_join_allowed": False, + "source_refs": relation["source_refs"], + } + cluster_edges.append(edge) + edge_pairs.add((source_cluster, target_cluster)) + cluster_ids = [row["cluster_id"] for row in cluster_build_rows] + sccs = _tarjan_scc(cluster_ids, sorted(edge_pairs)) + scc_rows: list[dict[str, Any]] = [] + cluster_to_scc: dict[str, str] = {} + for members_in_scc in sccs: + minted = mint_stage2_id("cluster_scc", members_in_scc, prefix="SCC") + cycle = len(members_in_scc) > 1 or any(left == right == members_in_scc[0] for left, right in edge_pairs) + row = { + "scc_id": minted["id"], + "member_cluster_ids": members_in_scc, + "cycle_preserved": cycle, + "mint_input_sha256": minted["mint_input_sha256"], + } + scc_rows.append(row) + for cluster_id in members_in_scc: + cluster_to_scc[cluster_id] = minted["id"] + scheduling_edges = sorted( + { + (cluster_to_scc[left], cluster_to_scc[right]) + for left, right in edge_pairs + if cluster_to_scc[left] != cluster_to_scc[right] + } + ) + scc_nodes = sorted(row["scc_id"] for row in scc_rows) + indegree = {node: 0 for node in scc_nodes} + adjacency: dict[str, set[str]] = {node: set() for node in scc_nodes} + for source, target in scheduling_edges: + if target not in adjacency[source]: + adjacency[source].add(target) + indegree[target] += 1 + scheduling_waves: list[list[str]] = [] + ready = sorted(node for node, degree in indegree.items() if degree == 0) + visited: set[str] = set() + while ready: + scheduling_waves.append(ready) + next_ready: list[str] = [] + for node in ready: + visited.add(node) + for target in sorted(adjacency[node]): + indegree[target] -= 1 + if indegree[target] == 0: + next_ready.append(target) + ready = sorted(set(next_ready)) + if len(visited) != len(scc_nodes): + raise IngressError("SCC_SCHEDULING_DAG_INVALID", "SCC condensation graph must be acyclic") + executable_ids = sorted( + row["cluster_id"] for row in cluster_build_rows if row["cluster_status"] == "EXECUTABLE" + ) + residual_ids = sorted(set(cluster_ids) - set(executable_ids)) + clusters: list[dict[str, Any]] = [] + for build_row in cluster_build_rows: + cluster_id = build_row["cluster_id"] + member_ids = build_row["member_ids"] + cluster_members = [ + { + "member_ref": str(by_id[member_id].get("member_ref", member_id)), + "member_kind": str(by_id[member_id].get("member_kind", "FACT")), + "source_refs": _dedupe_source_refs( + _coerce_source_ref(ref) for ref in by_id[member_id].get("source_refs", []) + ), + } + for member_id in member_ids + ] + internal_edges: list[dict[str, Any]] = [] + for relation in normalized_relations: + if relation["source_member_id"] in member_ids and relation["target_member_id"] in member_ids: + internal_edges.append( + { + "edge_id": relation["edge_id"], + "from_ref": relation["source_member_id"], + "to_ref": relation["target_member_id"], + "edge_class": relation["edge_class"], + "relation_key": relation["relation_key"], + "hard_join_allowed": relation["hard_join_allowed"], + "source_refs": relation["source_refs"], + } + ) + for edge in cluster_edges: + if cluster_id in {edge["source_cluster_id"], edge["target_cluster_id"]}: + internal_edges.append( + { + "edge_id": edge["edge_id"], + "from_ref": edge["source_cluster_id"], + "to_ref": edge["target_cluster_id"], + "edge_class": edge["edge_class"], + "relation_key": edge["relation_key"], + "hard_join_allowed": False, + "source_refs": edge["source_refs"], + } + ) + cluster = { + "cluster_id": cluster_id, + "cluster_status": build_row["cluster_status"], + "members": sorted(cluster_members, key=lambda row: row["member_ref"]), + "edges": sorted(internal_edges, key=lambda row: row["edge_id"]), + "scc_ids": [cluster_to_scc[cluster_id]], + "slice_ref": f"cluster_slices/{cluster_id}.json" if cluster_id in executable_ids else None, + "bundle_cohort_id": None, + "source_refs": build_row["source_refs"], + "derivation": { + "derivation_id": cluster_id, + "algorithm_version": algorithm_version, + "sorted_input_refs": sorted(member_ids), + "mint_input_sha256": build_row["mint_input_sha256"], + }, + } + clusters.append(cluster) + top_source_refs = _dedupe_source_refs( + ref for row in clusters for ref in row["source_refs"] + ) if clusters else [] + return { + "artifact_header": dict(artifact_header or _artifact_header()), + "clusters": sorted(clusters, key=lambda row: row["cluster_id"]), + "executable_cluster_ids": executable_ids, + "residual_review_cluster_ids": residual_ids, + "scheduling_waves": scheduling_waves, + "source_refs": top_source_refs, + "derivation": _derivation( + "cluster_plan_derivation", + cluster_ids or ["NO_CLUSTER"], + [scheduling_edges, [[row["scc_id"], row["member_cluster_ids"]] for row in scc_rows]], + ), + } + + + def compile_cluster_slices( + cluster_plan: Mapping[str, Any], + context_artifacts: Mapping[str, Mapping[str, Any]], + ) -> dict[str, dict[str, Any]]: + """Create immutable minimal source-ref slices for every cluster.""" + + projection_sources: dict[str, dict[str, Any]] = defaultdict(dict) + case_context = context_artifacts.get("case_context", {}) + for row in case_context.get("facts", []) if isinstance(case_context, dict) else []: + if isinstance(row, dict) and row.get("fact_id") is not None: + projection_sources["FACT"][str(row["fact_id"])] = row + evidence_inventory = context_artifacts.get("evidence_inventory", {}) + for row in evidence_inventory.get("items", []) if isinstance(evidence_inventory, dict) else []: + if not isinstance(row, dict): + continue + identifier = row.get("evidence_id", row.get("id")) + if identifier is not None: + projection_sources["EVIDENCE"][str(identifier)] = row + supplied_sources = context_artifacts.get("_projection_sources", {}) + if isinstance(supplied_sources, dict): + for kind, rows in supplied_sources.items(): + if isinstance(rows, dict): + projection_sources[str(kind)].update({str(key): value for key, value in rows.items()}) + + def materialize_projection( + kind: str, + source_id: str, + ) -> dict[str, Any]: + content = projection_sources.get(kind, {}).get(source_id) + if content is None: + raise IngressError( + "SLICE_PROJECTION_SOURCE_MISSING", + f"projection source is missing: {kind}:{source_id}", + ) + if not isinstance(content, dict): + raise IngressError( + "SLICE_PROJECTION_SOURCE_MISSING", + f"projection source is not an object: {kind}:{source_id}", + ) + raw = canonical_json_bytes(content) + if len(raw) > 262144: + raise IngressError("SLICE_PROJECTION_BUDGET_EXCEEDED", f"projection exceeds 262144 bytes: {kind}:{source_id}") + source_refs = _dedupe_source_refs(content.get("source_refs", [])) + matching_refs = [ + ref + for ref in source_refs + if ref.get("stage1_id") == source_id + and isinstance(ref.get("raw_value_sha256"), str) + and re.fullmatch(r"[a-f0-9]{64}", str(ref["raw_value_sha256"])) + ] + matching_hashes = {str(ref["raw_value_sha256"]) for ref in matching_refs} + if not matching_refs or len(matching_hashes) != 1: + raise IngressError( + "SLICE_PROJECTION_PROVENANCE_MISSING", + f"projection lacks one unambiguous source_id-bound raw hash: {kind}:{source_id}", + ) + raw_source_sha256 = next(iter(matching_hashes)) + projection_mint = mint_stage2_id("content_projection", [kind, source_id, content], prefix="CP") + return { + "projection_id": projection_mint["id"], + "projection_kind": kind, + "source_id": source_id, + "content_schema_id": None, + "content": content, + "raw_source_sha256": raw_source_sha256, + "canonical_content_sha256": canonical_digest(content), + "materialized_utf8_bytes": len(raw), + "projection_policy_id": "S2-SLICE-BOUNDED-PROJECTION-V1", + "truncated": False, + "source_refs": source_refs, + } + + projection_arrays = { + "FACT": "fact_projections", + "EVIDENCE": "evidence_projections", + "EVENT": "event_projections", + "LES_STRUCTURE": "les_structure_projections", + "SIGNAL_OCCURRENCE": "signal_occurrence_projections", + "REVIEW_ITEM": "review_item_projections", + "ACTIVE_PROFILE": "profile_projections", + } + slices: dict[str, dict[str, Any]] = {} + for cluster in cluster_plan.get("clusters", []): + cluster_id = cluster["cluster_id"] + source_refs = _dedupe_source_refs(cluster.get("source_refs", [])) + member_refs_by_kind: dict[str, list[str]] = defaultdict(list) + for member in cluster.get("members", []): + member_refs_by_kind[str(member.get("member_kind"))].append(str(member.get("member_ref"))) + minted = mint_stage2_id( + "cluster_slice", + [cluster_id, source_refs, sorted(member_refs_by_kind.items())], + prefix="SL", + ) + slice_body: dict[str, Any] = { + "artifact_header": dict(cluster_plan.get("artifact_header", _artifact_header())), + "cluster_id": cluster_id, + "slice_id": minted["id"], + "slice_schema_version": "stage2_cluster_slice.v1", + "immutable": True, + "source_refs": source_refs, + "fact_refs": sorted(set(member_refs_by_kind.get("FACT", []))), + "evidence_refs": sorted(set(member_refs_by_kind.get("EVIDENCE", []))), + "event_refs": sorted(set(member_refs_by_kind.get("EVENT", []))), + "les_structure_refs": sorted(set(member_refs_by_kind.get("LES_STRUCTURE", []))), + "signal_occurrence_refs": sorted(set(member_refs_by_kind.get("SIGNAL_OCCURRENCE", []))), + "review_keys": sorted(set(member_refs_by_kind.get("REVIEW_ITEM", []))), + "profile_refs": [], + "derivation": { + "derivation_id": minted["id"], + "algorithm_version": ALGORITHM_VERSION, + "sorted_input_refs": sorted( + str(member.get("member_ref")) for member in cluster.get("members", []) + ) or [cluster_id], + "mint_input_sha256": minted["mint_input_sha256"], + }, + } + all_projections: list[dict[str, Any]] = [] + for kind, array_name in projection_arrays.items(): + source_ids = sorted(set(member_refs_by_kind.get(kind, []))) + projections = [materialize_projection(kind, source_id) for source_id in source_ids] + slice_body[array_name] = projections + all_projections.extend(projections) + observed_projection_bytes = sum(row["materialized_utf8_bytes"] for row in all_projections) + if observed_projection_bytes > 2097152: + raise IngressError("SLICE_CONTENT_BUDGET_EXCEEDED", f"slice exceeds 2097152 bytes: {cluster_id}") + slice_body["projection_budget"] = { + "policy_id": "S2-SLICE-BOUNDED-PROJECTION-V1", + "max_projection_utf8_bytes": 262144, + "max_slice_content_utf8_bytes": 2097152, + "observed_projection_count": len(all_projections), + "observed_slice_content_utf8_bytes": observed_projection_bytes, + "budget_status": "PASS", + "raw_stage1_reread_required": False, + } + slice_body["slice_digest"] = canonical_digest(slice_body) + slices[cluster_id] = slice_body + return slices + + + _PII_PATTERNS: tuple[tuple[str, re.Pattern[str]], ...] = ( + ("KOREAN_RESIDENT_ID", re.compile(r"\b\d{6}-?[1-4]\d{6}\b")), + ("EMAIL", re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")), + ("KOREAN_PHONE", re.compile(r"\b01[016789]-?\d{3,4}-?\d{4}\b")), + ) + + + def _scan_pii(value: Any) -> list[str]: + rendered = canonical_json_bytes(value).decode("utf-8") + return [name for name, pattern in _PII_PATTERNS if pattern.search(rendered)] + + + def compile_bundle_plan( + cluster_plan: Mapping[str, Any], + cluster_slices: Mapping[str, Mapping[str, Any]], + release_lock: Mapping[str, Any], + *, + stage2_asset_root: str | os.PathLike[str] | None = None, + ) -> dict[str, Any]: + """Compile a data-only S2_10 handoff without materializing prompts.""" + + bundle = release_lock.get("bundle") + if not isinstance(bundle, dict): + raise IngressError("BUNDLE_RELEASE_CONTRACT_MISSING", "release bundle must be an object") + mode = bundle.get("mode") + release_class = release_lock.get("release_class") + if mode not in RELEASE_MODE or RELEASE_MODE[mode] != release_class: + raise IngressError("BUNDLE_RELEASE_CLASS_MISMATCH", f"{mode} is not valid for {release_class}") + handoff_contract_version = bundle.get("handoff_contract_version") + if handoff_contract_version != "S2_00_STRUCTURED_CONTEXT_HANDOFF_V2": + raise IngressError( + "HANDOFF_CONTRACT_VERSION_MISMATCH", + "S2_00 requires S2_00_STRUCTURED_CONTEXT_HANDOFF_V2", + ) + release_ref = str( + release_lock.get( + "release_id", + release_lock.get("stage2_release_digest", "stage2_release"), + ) + ) + verification_errors: list[str] = [] + + def normalize_sha256(value: Any, *, code: str) -> str: + if not isinstance(value, str) or re.fullmatch(r"[A-Fa-f0-9]{64}", value) is None: + verification_errors.append(code) + return "0" * 64 + return value.lower() + + def verify_opaque_ref(value: Any, *, label: str) -> str: + if not isinstance(value, dict): + verification_errors.append(f"{label}_REF_MISSING") + return "0" * 64 + try: + path = _safe_relative_path(value.get("path")).as_posix() + except (IngressError, TypeError): + verification_errors.append(f"{label}_REF_PATH_INVALID") + return "0" * 64 + expected = normalize_sha256( + value.get("sha256"), + code=f"{label}_HASH_UNBOUND", + ) + if stage2_asset_root is None: + verification_errors.append("STAGE2_ASSET_ROOT_MISSING") + return expected + try: + snapshot = open_bounded_snapshot( + stage2_asset_root, + path, + logical_input_id=label.lower(), + ) + except IngressError as exc: + verification_errors.append(f"{label}_ASSET_UNAVAILABLE") + return expected + if snapshot.raw_sha256 != expected: + verification_errors.append(f"{label}_HASH_MISMATCH") + return expected + + s2_10_agent_sha256 = verify_opaque_ref( + bundle.get("s2_10_agent_ref"), + label="S2_10_AGENT", + ) + s2_10_llm_binding_sha256 = verify_opaque_ref( + bundle.get("s2_10_llm_binding_ref"), + label="S2_10_LLM_BINDING", + ) + if normalize_sha256( + bundle.get("s2_10_agent_sha256"), + code="S2_10_AGENT_HASH_UNBOUND", + ) != s2_10_agent_sha256: + verification_errors.append("S2_10_AGENT_RELEASE_HASH_MISMATCH") + if normalize_sha256( + bundle.get("s2_10_llm_binding_sha256"), + code="S2_10_LLM_BINDING_HASH_UNBOUND", + ) != s2_10_llm_binding_sha256: + verification_errors.append("S2_10_LLM_BINDING_RELEASE_HASH_MISMATCH") + if bundle.get("context_cohort_policy_id") != "S2-CACHE-STRUCTURED-CONTEXT-HANDOFF-V2": + verification_errors.append("CONTEXT_COHORT_POLICY_MISMATCH") + if bundle.get("downstream_hybrid_status") != "HYBRID_RELEASE_BOUND": + verification_errors.append("S2_10_HYBRID_RELEASE_UNBOUND") + + selected_context_input = bundle.get("selected_context_refs", []) + if not isinstance(selected_context_input, list): + raise IngressError( + "SELECTED_CONTEXT_REFS_SHAPE", + "selected_context_refs must be an array", + ) + allowed_context_kinds = { + "ACTIVE_PROFILE", + "APPROVED_COMMON_AUTHORITY", + "LAW_VALUE_TOKEN", + "AUTHORITY_PROPOSITION", + } + selected_context_refs: list[dict[str, Any]] = [] + seen_context_ids: set[str] = set() + for index, row in enumerate(selected_context_input): + if not isinstance(row, dict): + raise IngressError( + "SELECTED_CONTEXT_REF_SHAPE", + f"selected context row {index} must be an object", + ) + context_ref_id = row.get("context_ref_id") + context_kind = row.get("context_kind") + if not isinstance(context_ref_id, str) or not context_ref_id: + raise IngressError( + "SELECTED_CONTEXT_REF_ID_INVALID", + f"selected context row {index} lacks context_ref_id", + ) + if context_ref_id in seen_context_ids: + verification_errors.append("SELECTED_CONTEXT_REF_ID_DUPLICATE") + seen_context_ids.add(context_ref_id) + if context_kind not in allowed_context_kinds: + raise IngressError( + "SELECTED_CONTEXT_KIND_INVALID", + f"unsupported context kind: {context_kind}", + ) + try: + relative_path = _safe_relative_path(row.get("path")).as_posix() + except (IngressError, TypeError) as exc: + raise IngressError( + "SELECTED_CONTEXT_PATH_INVALID", + f"invalid selected context path at row {index}", + ) from exc + raw_sha256 = normalize_sha256( + row.get("raw_sha256"), + code="SELECTED_CONTEXT_RAW_HASH_UNBOUND", + ) + canonical_sha256 = normalize_sha256( + row.get("canonical_sha256"), + code="SELECTED_CONTEXT_CANONICAL_HASH_UNBOUND", + ) + if row.get("order_index") != index: + verification_errors.append("SELECTED_CONTEXT_ORDER_INVALID") + observed_raw_sha256: str | None = None + observed_canonical_sha256: str | None = None + pii_codes: list[str] = [] + if stage2_asset_root is None: + verification_errors.append("STAGE2_ASSET_ROOT_MISSING") + else: + try: + snapshot = open_bounded_snapshot( + stage2_asset_root, + relative_path, + logical_input_id=f"selected_context:{context_ref_id}", + ) + observed_raw_sha256 = snapshot.raw_sha256 + try: + text = snapshot.raw.decode("utf-8", errors="strict") + canonical_text = unicodedata.normalize( + "NFC", + text.replace("\r\n", "\n").replace("\r", "\n"), + ) + observed_canonical_sha256 = hashlib.sha256( + canonical_text.encode("utf-8") + ).hexdigest() + pii_codes = _scan_pii(canonical_text) + except UnicodeDecodeError: + verification_errors.append("SELECTED_CONTEXT_NOT_UTF8") + except IngressError as exc: + verification_errors.append( + "SELECTED_CONTEXT_ASSET_UNAVAILABLE" + ) + if observed_raw_sha256 != raw_sha256: + verification_errors.append("SELECTED_CONTEXT_ASSET_HASH_MISMATCH") + if observed_canonical_sha256 != canonical_sha256: + verification_errors.append( + "SELECTED_CONTEXT_CANONICAL_HASH_MISMATCH" + ) + if pii_codes: + verification_errors.append("SELECTED_CONTEXT_PII") + selected_context_refs.append( + { + "context_ref_id": context_ref_id, + "context_kind": context_kind, + "path": relative_path, + "raw_sha256": raw_sha256, + "canonical_sha256": canonical_sha256, + "order_index": index, + "release_ref": str(row.get("release_ref", release_ref)), + } + ) + selected_context_ordered_refs_sha256 = canonical_digest( + selected_context_refs + ) + declared_context_digest = normalize_sha256( + bundle.get("selected_context_ordered_refs_sha256"), + code="SELECTED_CONTEXT_ORDERED_REFS_HASH_UNBOUND", + ) + if declared_context_digest != selected_context_ordered_refs_sha256: + verification_errors.append( + "SELECTED_CONTEXT_ORDERED_REFS_HASH_MISMATCH" + ) + if mode != "STRUCTURAL_FIXTURE" and not selected_context_refs: + verification_errors.append("SELECTED_CONTEXT_EMPTY") + + wave_by_scc: dict[str, int] = {} + for wave_ordinal, wave in enumerate( + cluster_plan.get("scheduling_waves", []) + ): + for scc_id in wave: + wave_by_scc[str(scc_id)] = wave_ordinal + cluster_rows = { + str(row.get("cluster_id")): row + for row in cluster_plan.get("clusters", []) + if isinstance(row, dict) and row.get("cluster_id") is not None + } + + valid_member_slices: list[dict[str, Any]] = [] + missing_member_slices: list[dict[str, Any]] = [] + for cluster_id in cluster_plan.get("executable_cluster_ids", []): + cluster_id = str(cluster_id) + cluster_row = cluster_rows.get(cluster_id, {}) + scc_ids = [ + str(value) + for value in cluster_row.get("scc_ids", []) + ] if isinstance(cluster_row, dict) else [] + dependency_wave_ordinal = min( + (wave_by_scc.get(value, 0) for value in scc_ids), + default=0, + ) + slice_body = cluster_slices.get(cluster_id) + member_slice = { + "cluster_id": cluster_id, + "path": f"context/cluster_slices/{cluster_id}.json", + "sha256": ( + canonical_digest(slice_body) + if isinstance(slice_body, Mapping) + else "0" * 64 + ), + "dependency_wave_ordinal": dependency_wave_ordinal, + } + if isinstance(slice_body, Mapping): + valid_member_slices.append(member_slice) + else: + missing_member_slices.append(member_slice) + + def build_cohort( + member_slices: Sequence[Mapping[str, Any]], + *, + extra_reason_codes: Sequence[str] = (), + ) -> dict[str, Any]: + cohort_member_cluster_ids = sorted( + str(row["cluster_id"]) for row in member_slices + ) + public_member_slices = sorted( + (dict(row) for row in member_slices), + key=lambda row: row["cluster_id"], + ) + cohort_membership_sha256 = canonical_digest( + cohort_member_cluster_ids + ) + member_slice_ref_set_sha256 = canonical_digest( + public_member_slices + ) + receipt_errors = sorted( + set(verification_errors).union(str(code) for code in extra_reason_codes) + ) + cohort_mint = mint_stage2_id( + "bundle_cohort", + [ + handoff_contract_version, + mode, + s2_10_agent_sha256, + s2_10_llm_binding_sha256, + selected_context_ordered_refs_sha256, + cohort_membership_sha256, + member_slice_ref_set_sha256, + ], + prefix="BC", + ) + materialization_input = { + "handoff_contract_version": handoff_contract_version, + "bundle_cohort_id": cohort_mint["id"], + "s2_10_agent_sha256": s2_10_agent_sha256, + "s2_10_llm_binding_sha256": s2_10_llm_binding_sha256, + "selected_context_ordered_refs_sha256": ( + selected_context_ordered_refs_sha256 + ), + "cohort_membership_sha256": cohort_membership_sha256, + "member_slice_ref_set_sha256": member_slice_ref_set_sha256, + } + receipt = { + "schema_version": ( + "stage2_s2_00_context_materialization_receipt.v2" + ), + "bundle_cohort_id": cohort_mint["id"], + "s2_10_agent_sha256": s2_10_agent_sha256, + "s2_10_llm_binding_sha256": s2_10_llm_binding_sha256, + "selected_context_ordered_refs_sha256": ( + selected_context_ordered_refs_sha256 + ), + "cohort_membership_sha256": cohort_membership_sha256, + "member_slice_ref_set_sha256": member_slice_ref_set_sha256, + "materialization_input_sha256": canonical_digest( + materialization_input + ), + "verification_status": ( + "PASS" if not receipt_errors else "NON_EXECUTABLE" + ), + "reason_codes": receipt_errors, + } + reason_codes = list(receipt_errors) + if mode == "STRUCTURAL_FIXTURE": + reason_codes.append("STRUCTURAL_FIXTURE_NOT_EXECUTABLE") + cohort_status = "STRUCTURAL_ONLY" + elif receipt_errors: + cohort_status = "NON_EXECUTABLE" + else: + cohort_status = "EXECUTABLE" + reason_codes = sorted(set(reason_codes)) + source_refs = _dedupe_source_refs( + ref + for cluster_id in cohort_member_cluster_ids + for ref in ( + cluster_rows.get(cluster_id, {}).get("source_refs", []) + if isinstance(cluster_rows.get(cluster_id), dict) + else [] + ) + ) + return { + "handoff_contract_version": handoff_contract_version, + "bundle_cohort_id": cohort_mint["id"], + "compile_mode": mode, + "release_class": release_class, + "cohort_status": cohort_status, + "selected_context_refs": list(selected_context_refs), + "selected_context_ordered_refs_sha256": ( + selected_context_ordered_refs_sha256 + ), + "member_slices": public_member_slices, + "cohort_member_cluster_ids": cohort_member_cluster_ids, + "s2_10_agent_sha256": s2_10_agent_sha256, + "s2_10_llm_binding_sha256": s2_10_llm_binding_sha256, + "context_materialization_receipt": receipt, + "forbidden_bulk_inputs_present": False, + "reason_codes": reason_codes, + "source_refs": source_refs, + "derivation": { + "derivation_id": cohort_mint["id"], + "algorithm_version": ALGORITHM_VERSION, + "sorted_input_refs": sorted( + cohort_member_cluster_ids + + [ + f"context:{selected_context_ordered_refs_sha256}", + f"agent:{s2_10_agent_sha256}", + f"binding:{s2_10_llm_binding_sha256}", + ] + ), + "mint_input_sha256": cohort_mint["mint_input_sha256"], + }, + } + + cohorts: list[dict[str, Any]] = [] + if valid_member_slices: + cohorts.append(build_cohort(valid_member_slices)) + for member_slice in missing_member_slices: + cohorts.append( + build_cohort( + [member_slice], + extra_reason_codes=["CLUSTER_SLICE_MISSING"], + ) + ) + public_cohorts = sorted( + cohorts, + key=lambda row: ( + row["cohort_member_cluster_ids"][0] + if row["cohort_member_cluster_ids"] + else row["bundle_cohort_id"] + ), + ) + executable_cohort_ids = sorted( + row["bundle_cohort_id"] + for row in public_cohorts + if row["cohort_status"] == "EXECUTABLE" + ) + non_executable_cohort_ids = sorted( + row["bundle_cohort_id"] + for row in public_cohorts + if row["cohort_status"] != "EXECUTABLE" + ) + top_refs = ( + _dedupe_source_refs( + ref for row in public_cohorts for ref in row["source_refs"] + ) + if public_cohorts + else list(cluster_plan.get("source_refs", [])) + ) + return { + "artifact_header": dict( + cluster_plan.get("artifact_header", _artifact_header()) + ), + "handoff_contract_version": handoff_contract_version, + "cohorts": public_cohorts, + "executable_bundle_cohort_ids": executable_cohort_ids, + "non_executable_bundle_cohort_ids": non_executable_cohort_ids, + "source_refs": top_refs, + "derivation": _derivation( + "bundle_plan_derivation", + [ + row["bundle_cohort_id"] for row in public_cohorts + ] or ["NO_BUNDLE_COHORT"], + [ + selected_context_ordered_refs_sha256, + s2_10_agent_sha256, + s2_10_llm_binding_sha256, + { + row["bundle_cohort_id"]: row["reason_codes"] + for row in public_cohorts + }, + ], + ), + } + + def validate_bundle_release_cohorts(bundle_plan: Mapping[str, Any]) -> dict[str, Any]: + """Recompute every cross-object invariant the JSON Schema cannot express.""" + + cohorts = bundle_plan.get("cohorts", []) + if not isinstance(cohorts, list): + raise IngressError( + "BUNDLE_COHORT_INVARIANT_FAILED", + "bundle_plan.cohorts must be an array", + ) + mode = cohorts[0].get("compile_mode") if cohorts else None + release_class = cohorts[0].get("release_class") if cohorts else None + invariant_errors: list[str] = [] + receipt_reason_codes = { + "S2_10_AGENT_REF_MISSING", + "S2_10_AGENT_REF_PATH_INVALID", + "S2_10_AGENT_HASH_UNBOUND", + "S2_10_AGENT_ASSET_UNAVAILABLE", + "S2_10_AGENT_HASH_MISMATCH", + "S2_10_AGENT_RELEASE_HASH_MISMATCH", + "S2_10_LLM_BINDING_REF_MISSING", + "S2_10_LLM_BINDING_REF_PATH_INVALID", + "S2_10_LLM_BINDING_HASH_UNBOUND", + "S2_10_LLM_BINDING_ASSET_UNAVAILABLE", + "S2_10_LLM_BINDING_HASH_MISMATCH", + "S2_10_LLM_BINDING_RELEASE_HASH_MISMATCH", + "S2_10_HYBRID_RELEASE_UNBOUND", + "STAGE2_ASSET_ROOT_MISSING", + "CONTEXT_COHORT_POLICY_MISMATCH", + "SELECTED_CONTEXT_REF_ID_DUPLICATE", + "SELECTED_CONTEXT_ORDER_INVALID", + "SELECTED_CONTEXT_RAW_HASH_UNBOUND", + "SELECTED_CONTEXT_CANONICAL_HASH_UNBOUND", + "SELECTED_CONTEXT_ASSET_UNAVAILABLE", + "SELECTED_CONTEXT_ASSET_HASH_MISMATCH", + "SELECTED_CONTEXT_CANONICAL_HASH_MISMATCH", + "SELECTED_CONTEXT_NOT_UTF8", + "SELECTED_CONTEXT_PII", + "SELECTED_CONTEXT_ORDERED_REFS_HASH_UNBOUND", + "SELECTED_CONTEXT_ORDERED_REFS_HASH_MISMATCH", + "SELECTED_CONTEXT_EMPTY", + "CLUSTER_SLICE_MISSING", + } + cohort_reason_codes = receipt_reason_codes | { + "STRUCTURAL_FIXTURE_NOT_EXECUTABLE" + } + + for index, row in enumerate(cohorts): + if not isinstance(row, dict): + invariant_errors.append(f"COHORT_{index}_SHAPE") + continue + row_mode = row.get("compile_mode") + row_release_class = row.get("release_class") + if row_mode not in RELEASE_MODE or RELEASE_MODE[row_mode] != row_release_class: + invariant_errors.append(f"COHORT_{index}_MODE_RELEASE_CLASS") + if mode is not None and row_mode != mode: + invariant_errors.append(f"COHORT_{index}_MODE_MIXED") + if release_class is not None and row_release_class != release_class: + invariant_errors.append(f"COHORT_{index}_RELEASE_CLASS_MIXED") + + selected_refs = row.get("selected_context_refs", []) + if not isinstance(selected_refs, list): + invariant_errors.append(f"COHORT_{index}_SELECTED_CONTEXT_SHAPE") + selected_refs = [] + if [item.get("order_index") for item in selected_refs if isinstance(item, dict)] != list( + range(len(selected_refs)) + ): + invariant_errors.append(f"COHORT_{index}_SELECTED_CONTEXT_ORDER") + selected_digest = canonical_digest(selected_refs) + if row.get("selected_context_ordered_refs_sha256") != selected_digest: + invariant_errors.append(f"COHORT_{index}_SELECTED_CONTEXT_DIGEST") + + member_ids = row.get("cohort_member_cluster_ids", []) + member_slices = row.get("member_slices", []) + if not isinstance(member_ids, list) or member_ids != sorted(member_ids): + invariant_errors.append(f"COHORT_{index}_MEMBER_ID_ORDER") + member_ids = list(member_ids) if isinstance(member_ids, list) else [] + if not isinstance(member_slices, list) or member_slices != sorted( + member_slices, + key=lambda item: str(item.get("cluster_id", "")) if isinstance(item, dict) else "", + ): + invariant_errors.append(f"COHORT_{index}_MEMBER_SLICE_ORDER") + member_slices = list(member_slices) if isinstance(member_slices, list) else [] + slice_ids = [ + item.get("cluster_id") + for item in member_slices + if isinstance(item, dict) + ] + if member_ids != slice_ids: + invariant_errors.append(f"COHORT_{index}_MEMBERSHIP_SET") + membership_digest = canonical_digest(member_ids) + slice_digest = canonical_digest(member_slices) + + receipt = row.get("context_materialization_receipt") + if not isinstance(receipt, dict): + invariant_errors.append(f"COHORT_{index}_RECEIPT_SHAPE") + receipt = {} + echoed_fields = { + "bundle_cohort_id": row.get("bundle_cohort_id"), + "s2_10_agent_sha256": row.get("s2_10_agent_sha256"), + "s2_10_llm_binding_sha256": row.get("s2_10_llm_binding_sha256"), + "selected_context_ordered_refs_sha256": selected_digest, + "cohort_membership_sha256": membership_digest, + "member_slice_ref_set_sha256": slice_digest, + } + for key, expected in echoed_fields.items(): + if receipt.get(key) != expected: + invariant_errors.append(f"COHORT_{index}_RECEIPT_{key.upper()}") + materialization_input = { + "handoff_contract_version": row.get("handoff_contract_version"), + **echoed_fields, + } + if receipt.get("materialization_input_sha256") != canonical_digest( + materialization_input + ): + invariant_errors.append(f"COHORT_{index}_MATERIALIZATION_DIGEST") + + expected_cohort = mint_stage2_id( + "bundle_cohort", + [ + row.get("handoff_contract_version"), + row_mode, + row.get("s2_10_agent_sha256"), + row.get("s2_10_llm_binding_sha256"), + selected_digest, + membership_digest, + slice_digest, + ], + prefix="BC", + )["id"] + if row.get("bundle_cohort_id") != expected_cohort: + invariant_errors.append(f"COHORT_{index}_ID_MINT") + + receipt_codes = receipt.get("reason_codes", []) + row_codes = row.get("reason_codes", []) + if not isinstance(receipt_codes, list) or not set(receipt_codes).issubset( + receipt_reason_codes + ): + invariant_errors.append(f"COHORT_{index}_RECEIPT_REASON_CODE") + if not isinstance(row_codes, list) or not set(row_codes).issubset( + cohort_reason_codes + ): + invariant_errors.append(f"COHORT_{index}_REASON_CODE") + + status = row.get("cohort_status") + receipt_status = receipt.get("verification_status") + if row_mode == "STRUCTURAL_FIXTURE": + if status != "STRUCTURAL_ONLY" or "STRUCTURAL_FIXTURE_NOT_EXECUTABLE" not in row_codes: + invariant_errors.append(f"COHORT_{index}_STRUCTURAL_STATUS") + elif receipt_status == "PASS": + if status != "EXECUTABLE" or row_codes: + invariant_errors.append(f"COHORT_{index}_EXECUTABLE_STATUS") + elif receipt_status == "NON_EXECUTABLE": + if status != "NON_EXECUTABLE" or not row_codes: + invariant_errors.append(f"COHORT_{index}_NON_EXECUTABLE_STATUS") + else: + invariant_errors.append(f"COHORT_{index}_RECEIPT_STATUS") + + expected_executable_ids = sorted( + str(row.get("bundle_cohort_id")) + for row in cohorts + if isinstance(row, dict) and row.get("cohort_status") == "EXECUTABLE" + ) + expected_non_executable_ids = sorted( + str(row.get("bundle_cohort_id")) + for row in cohorts + if isinstance(row, dict) and row.get("cohort_status") != "EXECUTABLE" + ) + if bundle_plan.get("executable_bundle_cohort_ids") != expected_executable_ids: + invariant_errors.append("TOP_EXECUTABLE_COHORT_PARTITION") + if bundle_plan.get("non_executable_bundle_cohort_ids") != expected_non_executable_ids: + invariant_errors.append("TOP_NON_EXECUTABLE_COHORT_PARTITION") + if invariant_errors: + raise IngressError( + "BUNDLE_COHORT_INVARIANT_FAILED", + ",".join(sorted(set(invariant_errors))), + details={"invariant_errors": sorted(set(invariant_errors))}, + ) + + mapping_pass = mode in RELEASE_MODE and RELEASE_MODE[mode] == release_class + executable = sorted( + cluster_id + for row in cohorts + if row.get("cohort_status") == "EXECUTABLE" + for cluster_id in row.get("cohort_member_cluster_ids", []) + ) + non_executable = sorted( + cluster_id + for row in cohorts + if row.get("cohort_status") == "NON_EXECUTABLE" + for cluster_id in row.get("cohort_member_cluster_ids", []) + ) + structural = sorted( + cluster_id + for row in cohorts + if row.get("cohort_status") == "STRUCTURAL_ONLY" + for cluster_id in row.get("cohort_member_cluster_ids", []) + ) + return { + "mapping_pass": mapping_pass, + "executable_cluster_ids": executable, + "non_executable_cluster_ids": non_executable, + "structural_cluster_ids": structural, + "passed": mapping_pass and (mode == "STRUCTURAL_FIXTURE" or bool(executable)), + } + + + def _write_fsynced(path: Path, payload: bytes) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL + if hasattr(os, "O_CLOEXEC"): + flags |= os.O_CLOEXEC + descriptor = os.open(path, flags, 0o600) + try: + view = memoryview(payload) + while view: + written = os.write(descriptor, view) + view = view[written:] + os.fsync(descriptor) + finally: + os.close(descriptor) + + + def _fsync_directory(path: Path) -> None: + flags = os.O_RDONLY + if hasattr(os, "O_DIRECTORY"): + flags |= os.O_DIRECTORY + descriptor = os.open(path, flags) + try: + os.fsync(descriptor) + finally: + os.close(descriptor) + + + def _published_tree_matches( + output_dir: Path, + run_binding_digest: str, + *, + stage2_asset_root: str | os.PathLike[str] | None = None, + ) -> bool: + status_path = output_dir / "ingress" / "ingress_status.json" + if not status_path.is_file() or status_path.is_symlink(): + return False + try: + snapshot = open_bounded_snapshot(output_dir, "ingress/ingress_status.json", logical_input_id="published_status") + status_value = load_json_strict(snapshot) + except IngressError: + return False + if not isinstance(status_value, dict): + return False + binding = status_value.get("run_binding_receipt", {}) + if not isinstance(binding, dict) or binding.get("run_binding_digest") != run_binding_digest: + return False + barrier = status_value.get("output_barrier", {}) + if not isinstance(barrier, dict) or barrier.get("written_last") is not True: + return False + expected_artifacts = barrier.get("artifacts", []) + if not isinstance(expected_artifacts, list): + return False + if barrier.get("artifact_set_digest") != canonical_digest(expected_artifacts): + return False + try: + schema_documents = _load_output_schemas( + Path(stage2_asset_root) + if stage2_asset_root is not None + else Path(__file__).resolve().parents[1] + ) + _validate_output_artifact( + "ingress/ingress_status.json", + status_value, + schema_documents, + ) + except IngressError: + return False + for row in expected_artifacts: + if not isinstance(row, dict): + return False + try: + artifact = open_bounded_snapshot(output_dir, row["path"], logical_input_id="published_artifact") + except IngressError: + return False + if artifact.raw_sha256 != row.get("raw_sha256"): + return False + try: + parsed_artifact = load_json_strict(artifact) + _validate_output_artifact(row["path"], parsed_artifact, schema_documents) + except IngressError: + return False + expected_paths = { + row.get("path") + for row in expected_artifacts + if isinstance(row, dict) and isinstance(row.get("path"), str) + } | {"ingress/ingress_status.json"} + observed_paths = { + path.relative_to(output_dir).as_posix() + for path in output_dir.rglob("*") + if path.is_file() and not path.is_symlink() + } + if expected_paths != observed_paths: + return False + return True + + + def _output_schema_id(relative_path: str) -> str: + if relative_path.startswith("context/"): + return CONTEXT_SCHEMA_ID + if relative_path.startswith("review/"): + return REVIEW_SCHEMA_ID + if relative_path.startswith("ingress/"): + return INGRESS_SCHEMA_ID + raise IngressError("OUTPUT_SCHEMA_FAMILY_UNKNOWN", f"no schema family for {relative_path}") + + + def publish_atomically( + output_dir: str | os.PathLike[str], + artifacts: Mapping[str, Any], + *, + run_binding_digest: str, + attempt_id: str, + stage2_asset_root: str | os.PathLike[str] | None = None, + ) -> dict[str, Any]: + """Publish a complete normal or diagnostic tree with one directory rename.""" + + output = Path(output_dir) + if not output.is_absolute(): + output = output.resolve() + if not re.fullmatch(r"[A-Za-z0-9_.-]{1,128}", attempt_id): + raise IngressError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + if "ingress/ingress_status.json" not in artifacts: + raise IngressError("OUTPUT_BARRIER_MISSING", "ingress_status must be supplied") + safe_paths = {_safe_relative_path(path).as_posix(): value for path, value in artifacts.items()} + if len(safe_paths) != len(artifacts): + raise IngressError("DUPLICATE_OUTPUT_PATH", "duplicate output paths after canonicalization") + schema_root = ( + Path(stage2_asset_root) + if stage2_asset_root is not None + else Path(__file__).resolve().parents[1] + ) + schema_documents = _load_output_schemas(schema_root) + for relative_path, supplied_value in safe_paths.items(): + value = load_json_strict(supplied_value) if isinstance(supplied_value, bytes) else supplied_value + _validate_output_artifact(relative_path, value, schema_documents) + if output.exists(): + if output.is_dir() and _published_tree_matches( + output, + run_binding_digest, + stage2_asset_root=schema_root, + ): + return {"status": "IDEMPOTENT_SUCCESS", "output_dir": str(output), "run_binding_digest": run_binding_digest} + raise IngressError("RUN_TUPLE_CONFLICT", "published output exists with a different binding") + parent = output.parent + parent.mkdir(parents=True, exist_ok=True) + staging_parent = parent / ".staging" + staging_parent.mkdir(parents=True, exist_ok=True) + staging = staging_parent / f"{output.name}.{attempt_id}" + if staging.exists(): + if staging.is_symlink() or staging.parent.resolve() != staging_parent.resolve(): + raise IngressError("STAGING_PATH_UNSAFE", "staging path is not safe") + shutil.rmtree(staging) + staging.mkdir(mode=0o700) + try: + artifact_receipt: list[dict[str, Any]] = [] + for relative_path in sorted(path for path in safe_paths if path != "ingress/ingress_status.json"): + value = safe_paths[relative_path] + payload = value if isinstance(value, bytes) else canonical_json_bytes(value) + _write_fsynced(staging / relative_path, payload) + artifact_receipt.append( + { + "logical_artifact_id": relative_path, + "path": relative_path, + "schema_id": _output_schema_id(relative_path), + "raw_sha256": hashlib.sha256(payload).hexdigest(), + } + ) + status = dict(safe_paths["ingress/ingress_status.json"]) + binding = status.get("run_binding_receipt") + if not isinstance(binding, dict) or binding.get("run_binding_digest") != run_binding_digest: + raise IngressError("RUN_BINDING_RECEIPT_MISMATCH", "status run binding does not match publish binding") + status["output_barrier"] = { + "barrier_id": "S2_00_INGRESS_STATUS_BARRIER", + "barrier_path": "ingress/ingress_status.json", + "publish_semantics": "STATUS_LAST_LOGICAL_COMMIT", + "canonical_output_root": f"stage2_runs/by-binding/{run_binding_digest}/", + "branch": "DIAGNOSTIC" if "ingress/technical_diagnostic.json" in safe_paths else "NORMAL", + "artifacts": artifact_receipt, + "artifact_set_digest": canonical_digest(artifact_receipt), + "non_status_artifacts_read_back_verified": True, + "written_last": True, + } + _validate_output_artifact( + "ingress/ingress_status.json", + status, + schema_documents, + ) + _write_fsynced(staging / "ingress/ingress_status.json", canonical_json_bytes(status)) + directories = sorted((path for path in staging.rglob("*") if path.is_dir()), key=lambda path: len(path.parts), reverse=True) + for directory in directories: + _fsync_directory(directory) + _fsync_directory(staging) + _fsync_directory(staging_parent) + os.rename(staging, output) + _fsync_directory(parent) + except BaseException: + if staging.exists() and staging.parent == staging_parent: + shutil.rmtree(staging) + raise + return {"status": "PUBLISHED", "output_dir": str(output), "run_binding_digest": run_binding_digest} + + + def _load_case_snapshots( + stage1_root: Path, + contracts: Sequence[Mapping[str, Any]], + release_lock: Mapping[str, Any], + ) -> tuple[dict[str, Snapshot], list[dict[str, Any]]]: + snapshots: dict[str, Snapshot] = {} + issues: list[dict[str, Any]] = [] + aggregate = 0 + max_file = int(release_lock.get("limits", {}).get("max_file_bytes", MAX_FILE_BYTES)) + max_run = int(release_lock.get("limits", {}).get("max_run_bytes", MAX_RUN_BYTES)) + for contract in contracts: + logical_id = str(contract["logical_input_id"]) + try: + snapshot = open_bounded_snapshot( + stage1_root, + str(contract["observed_path"]), + logical_input_id=logical_id, + max_bytes=max_file, + ) + except IngressError as exc: + if exc.code != "SOURCE_MISSING": + issues.append(_issue(exc.code, source_refs=[logical_id], message=str(exc))) + continue + aggregate += snapshot.byte_length + if aggregate > max_run: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "aggregate Stage 1 input budget exceeded") + snapshots[logical_id] = snapshot + return snapshots, issues + + + def _load_bound_completion_seal( + stage1_root: Path, + release_lock: Mapping[str, Any], + ) -> tuple[Mapping[str, Any] | None, Snapshot | None]: + dependency = release_lock.get("dependency_locks", {}).get("stage1", {}) + ref = dependency.get("completion_seal_ref", {}) if isinstance(dependency, dict) else {} + if not isinstance(ref, dict): + return None, None + path = ref.get("path") + digest = ref.get("sha256") + if path in {None, "PENDING_SEQUENTIAL_BIND"} or digest in {None, "PENDING_SEQUENTIAL_BIND"}: + return None, None + if not isinstance(path, str) or not isinstance(digest, str) or re.fullmatch(r"[A-Fa-f0-9]{64}", digest) is None: + raise IngressError("COMPLETION_SEAL_UNBOUND", "completion seal ref is not exactly bound") + snapshot = open_bounded_snapshot(stage1_root, path, logical_input_id="stage1_completion_seal") + if snapshot.raw_sha256 != digest.lower(): + raise IngressError("COMPLETION_SEAL_HASH_MISMATCH", "completion seal raw hash differs from release") + document = load_json_strict(snapshot) + if not isinstance(document, dict): + raise IngressError("COMPLETION_SEAL_SHAPE", "completion seal must be an object") + return document, snapshot + + + def _load_stage1_deployment_closure( + stage1_deployment_root: Path, + release_lock: Mapping[str, Any], + ) -> tuple[dict[str, Snapshot], dict[str, Any], list[dict[str, Any]]]: + """Load only the release-enumerated Stage 1 deployment closure.""" + + dependency = release_lock.get("dependency_locks", {}).get("stage1", {}) + locked_rows = dependency.get("concrete_paths", []) if isinstance(dependency, dict) else [] + if not isinstance(locked_rows, list) or not locked_rows: + raise IngressError("STAGE1_DEPENDENCY_LOCK_MISSING", "Stage 1 deployment closure is not enumerated") + expected_count = dependency.get("expected_concrete_path_count") + if expected_count is not None and expected_count != len(locked_rows): + raise IngressError("STAGE1_DEPENDENCY_COUNT_MISMATCH", "Stage 1 dependency row count is not sealed") + snapshots: dict[str, Snapshot] = {} + documents: dict[str, Any] = {} + source_rows: list[dict[str, Any]] = [] + seen_paths: set[str] = set() + aggregate = 0 + max_file = int(release_lock.get("limits", {}).get("max_file_bytes", MAX_FILE_BYTES)) + max_run = int(release_lock.get("limits", {}).get("max_run_bytes", MAX_RUN_BYTES)) + for index, locked in enumerate(locked_rows): + if not isinstance(locked, dict) or not isinstance(locked.get("path"), str): + raise IngressError("STAGE1_DEPENDENCY_ROW_SHAPE", f"invalid dependency row {index}") + path = _safe_relative_path(locked["path"]).as_posix() + if path in seen_paths: + raise IngressError("STAGE1_DEPENDENCY_DUPLICATE_PATH", f"duplicate dependency path: {path}") + seen_paths.add(path) + expected_hash = locked.get("sha256") + if not isinstance(expected_hash, str) or not re.fullmatch(r"[A-Fa-f0-9]{64}", expected_hash): + raise IngressError("STAGE1_DEPENDENCY_UNBOUND", f"dependency hash is not bound: {path}") + lock_id = str(locked.get("lock_id", f"S1-DEPLOY-{index + 1:03d}")) + snapshot = open_bounded_snapshot( + stage1_deployment_root, + path, + logical_input_id=f"deployment:{lock_id}", + max_bytes=max_file, + ) + aggregate += snapshot.byte_length + if aggregate > max_run: + raise IngressError("AGGREGATE_DEPLOYMENT_SIZE_LIMIT", "Stage 1 deployment closure exceeds byte budget") + if snapshot.raw_sha256 != expected_hash: + raise IngressError("STAGE1_DEPENDENCY_HASH_MISMATCH", f"deployment hash mismatch: {path}") + document = load_json_strict( + snapshot, + max_depth=int(release_lock.get("limits", {}).get("max_json_depth", MAX_JSON_DEPTH)), + max_items=int(release_lock.get("limits", {}).get("max_json_items", MAX_JSON_ITEMS)), + ) + snapshots[lock_id] = snapshot + documents[path] = document + schema_id = locked.get("schema_id") + source_rows.append( + { + "logical_input_id": f"deployment:{lock_id}", + "requirement_class": "UPSTREAM_DEPLOYMENT", + "expected_path": path, + "observed_path": path, + "resolution_source": "RELEASE_BOUND_CONTRACT_MANIFEST", + "schema_id": schema_id, + "schema_sha256": None, + "producer_id": None, + "producer_alias_id": None, + "adapter_id": "S2A-UPSTREAM-DEPLOYMENT-V1", + "raw_sha256": snapshot.raw_sha256, + "byte_length": snapshot.byte_length, + "run_identity_ref": {"value": None, "disposition": "NOT_APPLICABLE", "source_ref": path}, + "transaction_identity_ref": {"value": None, "disposition": "NOT_APPLICABLE", "source_ref": path}, + "parse_status": "PASS", + "schema_status": "UNEVALUABLE" if schema_id else "NOT_APPLICABLE", + "seal_status": "PASS", + "scope_technical_disposition": "AVAILABLE", + "impact_scope": "GLOBAL", + "scope_refs": [f"deployment:{lock_id}"], + "source_contract_row_refs": [f"deployment:{lock_id}"], + "reason_codes": [], + "downstream_allowed_actions": [], + "issue_codes": [], + } + ) + return snapshots, documents, source_rows + + + def _signal_source_contract_rows( + signal_all: Mapping[str, Any], + release_lock: Mapping[str, Any], + ) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + transaction_id = str(signal_all.get("manifest_transaction_id", "MISSING")) + family_contract = next( + ( + row + for row in _release_stage1_source_rows(release_lock) + if row.get("logical_input_id") == "signal_payload_family" + ), + {}, + ) + for file_row in signal_all.get("ordered_file_rows", []): + logical_id = f"signal_file:{int(file_row['manifest_index']):03d}" + hash_status = str(file_row.get("hash_status", "UNEVALUABLE")) + issue_codes = ["SIGNAL_FILE_HASH_MISMATCH"] if hash_status == "FAIL" else [] + rows.append( + { + "logical_input_id": logical_id, + "requirement_class": "SIGNAL_PAYLOAD", + "expected_path": str(file_row["physical_path"]), + "observed_path": str(file_row["physical_path"]), + "resolution_source": "RELEASE_BOUND_CONTRACT_MANIFEST", + "schema_id": None, + "schema_sha256": None, + "producer_id": family_contract.get("producer_id"), + "producer_alias_id": family_contract.get("producer_alias_id"), + "adapter_id": family_contract.get("adapter_id", "S2A-SIGNAL-PAYLOAD-FAMILY-V1"), + "raw_sha256": str(file_row["raw_sha256"]), + "byte_length": int(file_row["byte_length"]), + "run_identity_ref": {"value": None, "disposition": "MISSING", "source_ref": logical_id}, + "transaction_identity_ref": { + "value": transaction_id, + "disposition": "OBSERVED", + "source_ref": "signal_manifest", + }, + "parse_status": "PASS", + "schema_status": "UNEVALUABLE", + "seal_status": hash_status, + "scope_technical_disposition": "AVAILABLE_WITH_ISSUES" if issue_codes else "AVAILABLE", + "impact_scope": "SIGNAL", + "scope_refs": [logical_id], + "source_contract_row_refs": [logical_id], + "reason_codes": issue_codes, + "downstream_allowed_actions": [], + "issue_codes": issue_codes, + } + ) + return rows + + + def _snapshot_state_digest(snapshots: Sequence[Snapshot]) -> str: + """Digest stable source content, not hydration-local filesystem identity.""" + + return canonical_digest( + sorted( + [ + item.logical_input_id, + item.relative_path, + item.raw_sha256, + item.byte_length, + ] + for item in snapshots + ) + ) + + + def _verify_snapshot_state(snapshots: Sequence[Snapshot]) -> str: + rows: list[list[Any]] = [] + for item in snapshots: + path = Path(item.resolved_path) + if path.is_symlink(): + raise IngressError("SOURCE_SNAPSHOT_CHANGED", f"source became a symlink: {item.relative_path}") + try: + observed = path.stat(follow_symlinks=False) + except FileNotFoundError as exc: + raise IngressError("SOURCE_SNAPSHOT_CHANGED", f"source disappeared: {item.relative_path}") from exc + identity = (observed.st_dev, observed.st_ino, observed.st_size, observed.st_mtime_ns) + expected = (item.device, item.inode, item.byte_length, item.mtime_ns) + if identity != expected: + raise IngressError("SOURCE_SNAPSHOT_CHANGED", f"source changed: {item.relative_path}") + rows.append( + [ + item.logical_input_id, + item.relative_path, + item.raw_sha256, + item.byte_length, + ] + ) + return canonical_digest(sorted(rows)) + + + def _cluster_inputs(documents: Mapping[str, Any]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + ledger_rows = _array_rows(documents.get("fact_ledger_base"), ("facts", "fact_ledger", "rows", "items")) + bo_rows = _array_rows(documents.get("bo"), ("business_objects", "BO", "rows", "items")) + les_rows = _array_rows( + documents.get("legal_effect_structures"), + ("structures", "structure_records", "legal_effect_structures", "rows", "items"), + ) + evidence_rows = _array_rows(documents.get("evidence_indexed"), ("evidence", "evidence_items", "rows", "items")) + event_rows = _array_rows(documents.get("evidence_event_candidates"), ("events", "event_candidates", "rows", "items")) + members: list[dict[str, Any]] = [] + relations: list[dict[str, Any]] = [] + internal_by_kind_ref: dict[tuple[str, str], str] = {} + + def add_member( + kind: str, + member_ref: str, + logical_id: str, + pointer: str, + raw_value: Any, + ) -> str: + key = (kind, member_ref) + prior = internal_by_kind_ref.get(key) + if prior is not None: + return prior + internal_id = f"{kind}:{member_ref}" + internal_by_kind_ref[key] = internal_id + members.append( + { + "member_id": internal_id, + "member_ref": member_ref, + "member_kind": kind, + "source_refs": [_source_ref(logical_id, pointer, raw_value, stage1_id=member_ref)], + "scope_technical_disposition": "AVAILABLE", + } + ) + return internal_id + + bo_member_by_id: dict[str, str] = {} + for index, row in enumerate(bo_rows): + if not isinstance(row, dict): + continue + bo_id = str(row.get("BO_ID", f"BO-OCCURRENCE-{index}")) + bo_member_by_id[bo_id] = add_member("BO", bo_id, "bo", f"/business_objects/{index}", row) + + fact_member_by_id: dict[str, str] = {} + fact_members_by_bo: dict[str, list[str]] = defaultdict(list) + fact_members_by_evidence: dict[str, list[str]] = defaultdict(list) + fact_members_by_event: dict[str, list[str]] = defaultdict(list) + for index, row in enumerate(ledger_rows): + if not isinstance(row, dict): + continue + fact_id = str(row.get("fact_id", f"F-OCCURRENCE-{index}")) + member_id = add_member("FACT", fact_id, "fact_ledger_base", f"/facts/{index}", row) + fact_member_by_id[fact_id] = member_id + source_bo_id = row.get("source_bo_id") + if source_bo_id is not None: + fact_members_by_bo[str(source_bo_id)].append(member_id) + evidence_refs = row.get("evidence_refs", row.get("evidence_ids", [])) + if isinstance(evidence_refs, list): + for ref in evidence_refs: + fact_members_by_evidence[str(ref)].append(member_id) + event_refs = row.get("event_refs", row.get("event_ids", [])) + if isinstance(event_refs, list): + for ref in event_refs: + fact_members_by_event[str(ref)].append(member_id) + relation_arrays = [ + row.get(key) + for key in ("relations", "explicit_relations", "candidate_relations") + if isinstance(row.get(key), list) + ] + for relation_array in relation_arrays: + for relation_index, relation in enumerate(relation_array): + if not isinstance(relation, dict): + continue + target_ref = relation.get( + "target_fact_id", + relation.get("to_fact_id", relation.get("target_member_id")), + ) + relation_kind = str(relation.get("relation_kind", relation.get("kind", ""))) + if target_ref is None or relation_kind not in CANDIDATE_RELATION_KINDS | {"EXPLICIT_CASE_RELATION"}: + continue + relations.append( + { + "_deferred_source_fact_id": fact_id, + "_deferred_target_fact_id": str(target_ref), + "relation_kind": relation_kind, + "source_refs": [ + _source_ref( + "fact_ledger_base", + f"/facts/{index}/relations/{relation_index}", + relation, + ) + ], + } + ) + + for bo_id, fact_member_ids in sorted(fact_members_by_bo.items()): + bo_member = bo_member_by_id.get(bo_id) + if bo_member is None: + continue + for fact_member in sorted(set(fact_member_ids)): + relations.append( + { + "source_member_id": fact_member, + "target_member_id": bo_member, + "relation_kind": "SAME_BO_ID", + "source_refs": [_source_ref("bo", "", bo_id, stage1_id=bo_id)], + } + ) + + for index, row in enumerate(les_rows): + if not isinstance(row, dict): + continue + structure_ref = str(row.get("structure_id", row.get("legal_effect_structure_id", f"LES-OCCURRENCE-{index}"))) + les_member = add_member( + "LES_STRUCTURE", + structure_ref, + "legal_effect_structures", + f"/structures/{index}", + row, + ) + source_bo_ids = row.get("source_bo_ids", []) + if isinstance(source_bo_ids, list): + for bo_id in source_bo_ids: + bo_member = bo_member_by_id.get(str(bo_id)) + if bo_member is not None: + relations.append( + { + "source_member_id": les_member, + "target_member_id": bo_member, + "relation_kind": "SOURCE_BO_ATTACHMENT", + "source_refs": [ + _source_ref( + "legal_effect_structures", + f"/structures/{index}/source_bo_ids", + source_bo_ids, + ) + ], + } + ) + + for index, row in enumerate(evidence_rows): + if not isinstance(row, dict): + continue + evidence_id = str(row.get("evidence_id", row.get("id", f"EVIDENCE-OCCURRENCE-{index}"))) + evidence_member = add_member("EVIDENCE", evidence_id, "evidence_indexed", f"/items/{index}", row) + for fact_member in sorted(set(fact_members_by_evidence.get(evidence_id, []))): + relations.append( + { + "source_member_id": fact_member, + "target_member_id": evidence_member, + "relation_kind": "SAME_EVIDENCE_REF", + "source_refs": [_source_ref("fact_ledger_base", "", evidence_id, stage1_id=evidence_id)], + } + ) + + for index, row in enumerate(event_rows): + if not isinstance(row, dict): + continue + event_id = str(row.get("event_id", row.get("id", f"EVENT-OCCURRENCE-{index}"))) + event_member = add_member("EVENT", event_id, "evidence_event_candidates", f"/items/{index}", row) + for fact_member in sorted(set(fact_members_by_event.get(event_id, []))): + relations.append( + { + "source_member_id": fact_member, + "target_member_id": event_member, + "relation_kind": "SAME_EVENT_REF", + "source_refs": [_source_ref("fact_ledger_base", "", event_id, stage1_id=event_id)], + } + ) + + resolved_relations: list[dict[str, Any]] = [] + for relation in relations: + if "_deferred_source_fact_id" not in relation: + resolved_relations.append(relation) + continue + source_member = fact_member_by_id.get(str(relation["_deferred_source_fact_id"])) + target_member = fact_member_by_id.get(str(relation["_deferred_target_fact_id"])) + if source_member is None or target_member is None: + continue + resolved_relations.append( + { + "source_member_id": source_member, + "target_member_id": target_member, + "relation_kind": relation["relation_kind"], + "source_refs": relation["source_refs"], + } + ) + return members, resolved_relations + + + def _run_binding_digest( + snapshots: Mapping[str, Snapshot], + release_lock: Mapping[str, Any], + ) -> str: + input_set = [[key, snapshots[key].raw_sha256] for key in sorted(snapshots)] + binding = { + "input_set_digest": canonical_digest(input_set), + "stage2_release_digest": release_lock.get("_release_raw_sha256", release_lock.get("stage2_release_digest")), + "algorithm_digest": ALGORITHM_SEMANTIC_DIGEST, + "release_class": release_lock.get("release_class"), + } + return canonical_digest(binding) + + + def _input_set_digest( + snapshots: Mapping[str, Snapshot], + additional_snapshots: Sequence[Snapshot] = (), + ) -> str: + rows = [ + ["run", key, snapshots[key].relative_path, snapshots[key].raw_sha256] + for key in sorted(snapshots) + ] + rows.extend( + ["closure", item.logical_input_id, item.relative_path, item.raw_sha256] + for item in additional_snapshots + ) + return canonical_digest(sorted(rows, key=canonical_digest)) + + + def _make_run_binding_receipt( + snapshots: Mapping[str, Snapshot], + release_lock: Mapping[str, Any], + *, + request_id: str, + user_context_sha256: str, + workspace_context_sha256: str, + additional_snapshots: Sequence[Snapshot] = (), + ) -> dict[str, Any]: + input_digest = _input_set_digest(snapshots, additional_snapshots) + release_digest = str( + release_lock.get( + "_release_raw_sha256", + release_lock.get( + "release_digest", + release_lock.get("stage2_release_digest", "0" * 64), + ), + ) + ) + algorithm_digest = ALGORITHM_SEMANTIC_DIGEST + binding_digest = canonical_digest( + { + "input_set_digest": input_digest, + "stage2_release_digest": release_digest, + "algorithm_digest": algorithm_digest, + "release_class": release_lock.get("release_class"), + } + ) + return { + "schema_version": "stage2_s2_00_run_binding_receipt.v1.1", + "request_id": request_id, + "run_id": f"S2RUN-{binding_digest}", + "input_set_digest": input_digest, + "stage2_release_digest": release_digest, + "algorithm_digest": algorithm_digest, + "release_class": release_lock.get("release_class"), + "run_binding_digest": binding_digest, + "canonical_output_root": f"stage2_runs/by-binding/{binding_digest}/", + "run_identity_derivation": "RUN_ID_PREFIXED_FROM_RUN_BINDING_DIGEST", + "output_root_derivation": "stage2_runs/by-binding//", + "user_context_sha256": user_context_sha256, + "workspace_context_sha256": workspace_context_sha256, + } + + + def canonical_run_id(run_binding_digest: str) -> str: + """Derive the immutable run identifier from the complete binding digest.""" + + if re.fullmatch(r"[a-f0-9]{64}", run_binding_digest) is None: + raise IngressError( + "RUN_BINDING_DIGEST_INVALID", + "canonical run id requires one lowercase SHA-256 digest", + ) + return f"S2RUN-{run_binding_digest}" + + + def _compact_conservation_checks( + checks: Sequence[Mapping[str, Any]], + ) -> list[dict[str, Any]]: + compact: list[dict[str, Any]] = [] + for check in checks: + check_id = str(check.get("check_id", "UNNAMED_CONSERVATION_CHECK")) + status_value = str(check.get("status", "UNEVALUABLE")) + status = status_value if status_value in {"PASS", "FAIL", "UNEVALUABLE"} else "UNEVALUABLE" + observed_payload = {key: value for key, value in check.items() if key not in {"status"}} + left_digest = canonical_digest(observed_payload) if status != "UNEVALUABLE" else None + right_digest = left_digest if status == "PASS" else canonical_digest([check_id, "EXPECTED"]) if status == "FAIL" else None + left_count = next( + ( + int(check[key]) + for key in ("left_count", "bo_count", "source_bo_ref_count") + if isinstance(check.get(key), int) + ), + None, + ) + right_count = next( + ( + int(check[key]) + for key in ("right_count", "source_bo_ref_count", "bo_count") + if isinstance(check.get(key), int) + ), + None, + ) + compact.append( + { + "check_id": check_id, + "status": status, + "left_counter_digest": left_digest, + "right_counter_digest": right_digest, + "left_count": left_count, + "right_count": right_count, + "source_refs": [check_id], + "issue_codes": [f"{check_id}_FAILED"] if status == "FAIL" else [], + } + ) + return compact + + + def _compact_review_receipt( + normalized_reviews: Mapping[str, Any], + ) -> dict[str, Any]: + normalized = normalized_reviews.get("normalized_occurrences", []) + raw = normalized_reviews.get("raw_occurrences", []) + counts = dict(normalized_reviews.get("partition_counts", {})) + for key in ("SUPPORTED", "CONDITIONAL", "UNRESOLVED", "EXCLUDED", "UNMAPPED"): + counts.setdefault(key, 0) + return { + "schema_version": "stage2_review_normalization_receipt.v1", + "adapter_ids": list(normalized_reviews.get("adapter_ids", [])), + "raw_occurrence_count": len(raw), + "normalized_occurrence_count": len(normalized), + "partition_counts": counts, + "unmapped_occurrence_count": counts["UNMAPPED"], + "conservation_status": str(normalized_reviews.get("conservation_status", "FAIL")), + "ordered_occurrence_refs": [ + str(row.get("review_key", {}).get("value")) + for row in normalized + if row.get("review_key", {}).get("value") + ], + } + + + def _build_issue_ledger( + issues: Sequence[Mapping[str, Any]], + normalized_reviews: Mapping[str, Any], + *, + run_id: str, + input_set_digest: str, + ) -> dict[str, Any]: + issue_rows: list[dict[str, Any]] = [] + seen: set[str] = set() + for index, issue in enumerate(issues): + issue_code = str(issue.get("issue_code", "UNSPECIFIED_ISSUE")) + source_refs = sorted(set(str(item) for item in issue.get("scope_refs", []))) or ["S2_00"] + issue_mint = mint_stage2_id( + "issue", + [issue_code, source_refs, index], + prefix="ISS", + ) + if issue_mint["id"] in seen: + continue + seen.add(issue_mint["id"]) + raw_severity = str(issue.get("severity", "ERROR")).upper() + technical_severity = { + "INFO": "INFO", + "REVIEW": "REVIEW", + "WARNING": "HARD_WARNING", + "HARD_WARNING": "HARD_WARNING", + "ERROR": "BLOCK", + "BLOCK": "BLOCK", + }.get(raw_severity, "REVIEW") + issue_rows.append( + { + "issue_id": issue_mint["id"], + "issue_code": issue_code, + "technical_severity": technical_severity, + "review_partition": "UNRESOLVED", + "impact_scope": str(issue.get("impact_scope", "GLOBAL")), + "scope_refs": source_refs, + "source_contract_row_refs": sorted( + set(str(item) for item in issue.get("source_contract_row_refs", source_refs)) + ), + "reason_codes": sorted(set(str(item) for item in issue.get("reason_codes", [issue_code]))), + "downstream_allowed_actions": sorted( + set(str(item) for item in issue.get("downstream_allowed_actions", [])) + ), + "source_refs": source_refs, + "status": "OPEN", + "upstream_review_key": None, + "raw_item_sha256": None, + } + ) + for occurrence in normalized_reviews.get("normalized_occurrences", []): + if occurrence.get("partition") != "UNMAPPED": + continue + review_key = occurrence["review_key"]["value"] + issue_mint = mint_stage2_id( + "issue", + ["UNMAPPED_REVIEW_STATUS", review_key], + prefix="ISS", + ) + issue_rows.append( + { + "issue_id": issue_mint["id"], + "issue_code": "UNMAPPED_REVIEW_STATUS", + "technical_severity": "REVIEW", + "review_partition": "UNMAPPED", + "impact_scope": "REVIEW_ITEM", + "scope_refs": [review_key], + "source_contract_row_refs": occurrence["source_contract_row_refs"], + "reason_codes": ["UNMAPPED_REVIEW_STATUS"], + "downstream_allowed_actions": occurrence["downstream_allowed_actions"], + "source_refs": occurrence["source_contract_row_refs"], + "status": "OPEN", + "upstream_review_key": review_key, + "raw_item_sha256": occurrence["source_item_raw_sha256"], + } + ) + return { + "schema_version": "stage2_issue_ledger_base.v1", + "producer_id": "S2_00", + "run_id": run_id, + "input_set_digest": input_set_digest, + "mapping_table_version": "S2-REVIEW-MAP-V1", + "issues": sorted(issue_rows, key=lambda row: row["issue_id"]), + "raw_review_occurrence_count": len(normalized_reviews.get("raw_occurrences", [])), + "normalized_review_occurrence_count": len(normalized_reviews.get("normalized_occurrences", [])), + "review_conservation_status": str(normalized_reviews.get("conservation_status", "FAIL")), + } + + + def _route( + source_rows: Sequence[Mapping[str, Any]], + cluster_plan: Mapping[str, Any], + cohort_receipt: Mapping[str, Any], + issues: Sequence[Mapping[str, Any]], + ) -> str: + identity_unavailable = any( + row.get("requirement_class") == "IDENTITY_BACKBONE" + and row.get("scope_technical_disposition") == "UNAVAILABLE" + for row in source_rows + ) + diagnostic_issue_codes = { + "RELEASE_SOURCE_CONTRACT_MISSING", + "RELEASE_SOURCE_PATH_MISMATCH", + "RAW_HASH_MISMATCH", + "SCHEMA_HASH_MISMATCH", + "SCHEMA_ID_MISMATCH", + "RUN_IDENTITY_CONFLICT", + "TRANSACTION_IDENTITY_CONFLICT", + "BO_FACT_CONSERVATION_FAILED", + "FACT_ID_CONSERVATION_FAILED", + "CURRENT_V8_LEDGER_EXTENSION_MISSING", + } + observed_issue_codes = {str(item.get("issue_code")) for item in issues} + if identity_unavailable or observed_issue_codes & diagnostic_issue_codes or not cluster_plan.get("clusters"): + return "TO_S2_40_STATUS_ONLY" + if not cohort_receipt.get("executable_cluster_ids"): + return "TO_S2_40_STATUS_ONLY" + return "TO_S2_10_WITH_ISSUES" if issues else "TO_S2_10" + + + def execute_ingress( + stage1_run_root: str | os.PathLike[str], + release_lock: Mapping[str, Any], + *, + output_dir: str | os.PathLike[str] | None, + attempt_id: str, + run_id: str = "S2-00-REQUEST", + user_context_sha256: str = "0" * 64, + workspace_context_sha256: str = "0" * 64, + stage1_deployment_root: str | os.PathLike[str] | None = None, + stage2_asset_root: str | os.PathLike[str] | None = None, + contract_manifest: Mapping[str, Any] | None = None, + hydration_stability_receipt: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Execute C00→C05→C10→C15 for a canary or production case run.""" + + if release_lock.get("release_class") == "DEV_FIXTURE_RELEASE": + raise IngressError("DEV_FIXTURE_REAL_RUN_FORBIDDEN", "DEV fixture release cannot publish a case run") + if output_dir is None: + raise IngressError("OUTPUT_DIR_REQUIRED", "output_dir is required for canary/production") + if stage1_deployment_root is None: + raise IngressError("STAGE1_DEPLOYMENT_ROOT_REQUIRED", "Stage 1 deployment root is required") + if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", run_id): + raise IngressError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(hydration_stability_receipt, dict): + raise IngressError( + "HYDRATION_STABILITY_RECEIPT_REQUIRED", + "canary and production ingress require the remote two-pass hydration receipt", + ) + for label, value in ( + ("user_context_sha256", user_context_sha256), + ("workspace_context_sha256", workspace_context_sha256), + ): + if not re.fullmatch(r"[A-Fa-f0-9]{64}", value): + raise IngressError("RUN_CONTEXT_HASH_INVALID", f"{label} must be a SHA-256 digest") + root_arg = Path(stage1_run_root) + deployment_root_arg = Path(stage1_deployment_root) + asset_root_arg = Path(stage2_asset_root) if stage2_asset_root is not None else Path(__file__).resolve().parents[1] + for candidate, code in ( + (root_arg, "SYMLINK_ROOT_REJECTED"), + (deployment_root_arg, "SYMLINK_DEPLOYMENT_ROOT_REJECTED"), + (asset_root_arg, "SYMLINK_ASSET_ROOT_REJECTED"), + ): + if candidate.is_symlink(): + raise IngressError(code, "approved root itself may not be a symlink") + root = root_arg.resolve(strict=True) + deployment_root = deployment_root_arg.resolve(strict=True) + asset_root = ( + asset_root_arg.resolve(strict=True) + if stage2_asset_root is not None + else Path(__file__).resolve().parents[1] + ) + deployment_snapshots, deployment_documents, deployment_rows = _load_stage1_deployment_closure( + deployment_root, + release_lock, + ) + contracts = resolve_stage1_sources(root, contract_manifest) + snapshots, snapshot_issues = _load_case_snapshots(root, contracts, release_lock) + completion_seal, completion_seal_snapshot = _load_bound_completion_seal(root, release_lock) + ingress = validate_ingress_contracts( + snapshots, + contracts, + release_lock, + deployment_snapshots=deployment_snapshots, + deployment_documents=deployment_documents, + completion_seal=completion_seal, + contract_manifest=contract_manifest, + ) + documents = ingress["documents"] + issues = list(snapshot_issues) + list(ingress["issues"]) + signal_all: dict[str, Any] | None = None + if isinstance(documents.get("signal_manifest"), dict): + try: + max_run = int(release_lock.get("limits", {}).get("max_run_bytes", MAX_RUN_BYTES)) + already_loaded = sum(snapshot.byte_length for snapshot in snapshots.values()) + sum( + snapshot.byte_length for snapshot in deployment_snapshots.values() + ) + remaining = max_run - already_loaded + if remaining < 0: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "case and deployment closure exceed aggregate run budget") + signal_all = expand_stage2_signal_all( + root, + documents["signal_manifest"], + max_file_bytes=int(release_lock.get("limits", {}).get("max_file_bytes", MAX_FILE_BYTES)), + max_total_bytes=remaining, + signal_registry=deployment_documents.get("signals/signal_registry.v2.json"), + ) + signal_all = bind_signal_occurrences(signal_all, documents) + issues.extend(signal_all.get("issues", [])) + except IngressError as exc: + issues.append(_issue(exc.code, impact_scope="SIGNAL", source_refs=["signal_manifest"], message=str(exc))) + routing_activation = documents.get("domain_activation_manifest") + if isinstance(routing_activation, dict): + try: + parsed_signal_documents = signal_all.get("_parsed_documents_by_path", {}) if signal_all else {} + signal_activation = parsed_signal_documents.get("domain_activation_manifest.json") + if signal_activation is None: + raise IngressError( + "SG01_SIGNAL_ARTIFACT_MISSING", + "signal ALL does not contain domain_activation_manifest.json", + ) + signal_activation_row = next( + ( + row + for row in signal_all.get("ordered_file_rows", []) + if row.get("file_path") == "domain_activation_manifest.json" + ), + {}, + ) + verify_activation_projection( + routing_activation, + signal_activation, + routing_raw_sha256=snapshots.get("domain_activation_manifest").raw_sha256 if snapshots.get("domain_activation_manifest") else None, + signal_raw_sha256=signal_activation_row.get("raw_sha256"), + ) + except IngressError as exc: + issues.append(_issue(exc.code, impact_scope="SIGNAL", source_refs=["domain_activation_manifest", "signal_sg01_activation"], message=str(exc))) + seal_deployment_snapshots = { + "stage1_domain_registry_index": snapshot + for lock_id, snapshot in deployment_snapshots.items() + if snapshot.relative_path == "domains/_registry_index.json" + } + seals = verify_cross_artifact_seals(documents, snapshots, seal_deployment_snapshots) + issues.extend(seals["issues"]) + review_docs = {key: value for key, value in documents.items() if "review_handoff" in key or "soft_gate_handoff" in key} + normalized_reviews = normalize_review_items(review_docs, release_lock) + issues.extend(normalized_reviews.get("_issues", [])) + conservation = check_conservation( + documents, + signal_all=signal_all, + normalized_reviews=normalized_reviews, + source_snapshots=snapshots, + ) + issues.extend(conservation["issues"]) + signal_snapshots = list(signal_all.get("_payload_snapshots", [])) if signal_all else [] + closure_snapshots = list(deployment_snapshots.values()) + signal_snapshots + all_snapshots = list(snapshots.values()) + closure_snapshots + if completion_seal_snapshot is not None: + all_snapshots.append(completion_seal_snapshot) + snapshot_start_digest = _snapshot_state_digest(all_snapshots) + input_set_digest = _input_set_digest(snapshots, closure_snapshots) + run_binding_receipt = _make_run_binding_receipt( + snapshots, + release_lock, + request_id=run_id, + user_context_sha256=user_context_sha256, + workspace_context_sha256=workspace_context_sha256, + additional_snapshots=closure_snapshots, + ) + run_binding_digest = run_binding_receipt["run_binding_digest"] + run_id = canonical_run_id(run_binding_digest) + context_schema_snapshot = open_bounded_snapshot( + asset_root, + "schemas/context.schema.json", + logical_input_id="stage2_context_schema", + ) + artifact_header = _artifact_header( + schema_sha256=context_schema_snapshot.raw_sha256, + run_id=run_id, + input_set_digest=input_set_digest, + stage2_release_digest=run_binding_receipt["stage2_release_digest"], + algorithm_digest=run_binding_receipt["algorithm_digest"], + release_class=str(release_lock["release_class"]), + ) + domain_configs = { + match.group(1): value + for path, value in deployment_documents.items() + if (match := re.fullmatch(r"domains/([^/]+)/domain_config\.json", path)) is not None + } + routing_payload = ( + _activation_payload(documents["domain_activation_manifest"]) + if isinstance(documents.get("domain_activation_manifest"), dict) + else {} + ) + active_domain_ids = routing_payload.get("active_domain_ids", []) + if isinstance(active_domain_ids, list): + for domain_id in sorted(set(str(value) for value in active_domain_ids)): + if domain_id not in domain_configs: + issues.append( + _issue( + "ACTIVE_DOMAIN_CONFIG_MISSING", + impact_scope="CLUSTER", + source_refs=[f"domain_config:{domain_id}"], + ) + ) + case_context = build_case_context( + documents, + run_binding_digest=run_binding_digest, + issues=issues, + artifact_header=artifact_header, + signal_all=signal_all, + ) + evidence_inventory = build_evidence_inventory( + documents, + run_binding_digest=run_binding_digest, + artifact_header=artifact_header, + ) + object_registry = build_object_registry( + documents, + run_binding_digest=run_binding_digest, + artifact_header=artifact_header, + ) + party_context = build_party_and_title_context( + documents, + run_binding_digest=run_binding_digest, + artifact_header=artifact_header, + ) + slot_crosswalk = build_slot_crosswalk( + documents, + domain_configs, + run_binding_digest=run_binding_digest, + artifact_header=artifact_header, + ) + members, relations = _cluster_inputs(documents) + cluster_plan = compile_cluster_plan(members, relations, artifact_header=artifact_header) + contexts = { + "case_context": case_context, + "evidence_inventory": evidence_inventory, + "object_registry": object_registry, + "party_and_title_context": party_context, + "slot_crosswalk": slot_crosswalk, + "_projection_sources": { + "EVENT": { + str(row.get("event_id", row.get("id"))): row + for row in _array_rows(documents.get("evidence_event_candidates"), ("events", "event_candidates", "rows", "items")) + if isinstance(row, dict) and (row.get("event_id") is not None or row.get("id") is not None) + }, + "LES_STRUCTURE": { + str(row.get("structure_id", row.get("legal_effect_structure_id"))): row + for row in _array_rows(documents.get("legal_effect_structures"), ("structures", "structure_records", "rows", "items")) + if isinstance(row, dict) and (row.get("structure_id") is not None or row.get("legal_effect_structure_id") is not None) + }, + "SIGNAL_OCCURRENCE": { + str(row.get("occurrence_ref")): row + for row in (signal_all or {}).get("record_occurrences", []) + if row.get("occurrence_ref") is not None + }, + "REVIEW_ITEM": { + str(row.get("review_key", {}).get("value")): row + for row in normalized_reviews.get("normalized_occurrences", []) + if row.get("review_key", {}).get("value") is not None + }, + "ACTIVE_PROFILE": { + str(domain_id): config + for domain_id, config in domain_configs.items() + if domain_id in set(str(value) for value in active_domain_ids) + }, + }, + } + slices = compile_cluster_slices(cluster_plan, contexts) + effective_release_lock = dict(release_lock) + if not isinstance(effective_release_lock.get("bundle"), dict): + issues.append(_issue("BUNDLE_RELEASE_CONTRACT_MISSING", impact_scope="GLOBAL", source_refs=["stage2_release"])) + effective_release_lock["bundle"] = { + "mode": { + "DEV_FIXTURE_RELEASE": "STRUCTURAL_FIXTURE", + "SUBSET_CANARY_RELEASE": "SUBSET_CANARY", + "PRODUCTION_RELEASE": "PRODUCTION", + }.get(str(release_lock.get("release_class")), "STRUCTURAL_FIXTURE"), + "handoff_contract_version": "S2_00_STRUCTURED_CONTEXT_HANDOFF_V2", + "context_cohort_policy_id": "S2-CACHE-STRUCTURED-CONTEXT-HANDOFF-V2", + "s2_10_agent_ref": { + "path": "agent_scripts/Stage_2_S2_10.yml", + "sha256": "0" * 64, + }, + "s2_10_llm_binding_ref": { + "path": "deployment/stage2_s2_10_llm_binding.yml", + "sha256": "0" * 64, + }, + "s2_10_agent_sha256": "0" * 64, + "s2_10_llm_binding_sha256": "0" * 64, + "selected_context_refs": [], + "selected_context_ordered_refs_sha256": canonical_digest([]), + "downstream_hybrid_status": "PENDING_REIMPLEMENTATION_AND_RESEAL", + } + bundle_plan = compile_bundle_plan( + cluster_plan, + slices, + effective_release_lock, + stage2_asset_root=asset_root, + ) + cohort_by_cluster = { + cluster_id: row + for row in bundle_plan.get("cohorts", []) + for cluster_id in row.get("cohort_member_cluster_ids", []) + } + for cluster in cluster_plan.get("clusters", []): + cohort = cohort_by_cluster.get(cluster["cluster_id"]) + if cohort is not None: + cluster["bundle_cohort_id"] = cohort["bundle_cohort_id"] + if cohort["cohort_status"] != "EXECUTABLE" and cluster["cluster_status"] == "EXECUTABLE": + cluster["cluster_status"] = "NON_EXECUTABLE" + for code in cohort.get("reason_codes", []): + issues.append( + _issue( + str(code), + impact_scope="CLUSTER", + source_refs=[cluster["cluster_id"], cohort["bundle_cohort_id"]], + ) + ) + cohort_receipt = validate_bundle_release_cohorts(bundle_plan) + final_executable = cohort_receipt["executable_cluster_ids"] + final_residual = sorted( + set(cluster["cluster_id"] for cluster in cluster_plan.get("clusters", [])) + - set(final_executable) + ) + cluster_plan["executable_cluster_ids"] = final_executable + cluster_plan["residual_review_cluster_ids"] = final_residual + executable_scc_ids = { + scc_id + for cluster in cluster_plan.get("clusters", []) + if cluster["cluster_id"] in set(final_executable) + for scc_id in cluster.get("scc_ids", []) + } + cluster_plan["scheduling_waves"] = [ + [scc_id for scc_id in wave if scc_id in executable_scc_ids] + for wave in cluster_plan.get("scheduling_waves", []) + if any(scc_id in executable_scc_ids for scc_id in wave) + ] + route = _route(ingress["source_contract_rows"], cluster_plan, cohort_receipt, issues) + snapshot_end_digest = _verify_snapshot_state(all_snapshots) + if snapshot_end_digest != snapshot_start_digest: + raise IngressError("SOURCE_SNAPSHOT_CHANGED", "source closure changed after the one-read snapshot") + source_rows = list(ingress["source_contract_rows"]) + if signal_all: + source_rows.extend(_signal_source_contract_rows(signal_all, release_lock)) + source_rows.extend(deployment_rows) + source_rows = sorted(source_rows, key=lambda row: row["logical_input_id"]) + issue_codes = sorted(set(str(item["issue_code"]) for item in issues)) + source_counts = { + "declared": len(source_rows), + "observed": sum(row["raw_sha256"] is not None for row in source_rows), + "available": sum(row["scope_technical_disposition"] == "AVAILABLE" for row in source_rows), + "with_issues": sum(row["scope_technical_disposition"] == "AVAILABLE_WITH_ISSUES" for row in source_rows), + "unavailable": sum(row["scope_technical_disposition"] == "UNAVAILABLE" for row in source_rows), + } + intake_report = { + "schema_version": "stage2_s2_00_intake_report.v1", + "run_id": run_id, + "source_counts": source_counts, + "conservation_checks": _compact_conservation_checks(conservation["checks"]), + "review_normalization_receipt": _compact_review_receipt(normalized_reviews), + "minimum_coherent_package_possible": route != "TO_S2_40_STATUS_ONLY", + "scope_summary": [ + { + "scope_technical_disposition": row["scope_technical_disposition"], + "impact_scope": row["impact_scope"], + "scope_refs": row["scope_refs"], + "source_contract_row_refs": row["source_contract_row_refs"], + "reason_codes": row["reason_codes"], + "downstream_allowed_actions": row["downstream_allowed_actions"], + } + for row in source_rows + ], + "issue_codes": issue_codes, + } + manifest = { + "schema_version": "stage2_s2_00_stage1_input_manifest.v1.1", + "run_id": run_id, + "release_class": release_lock["release_class"], + "source_rows": source_rows, + "source_row_order": [row["logical_input_id"] for row in source_rows], + "signal_all_adapter_id": "S2A-SIGNAL-ALL-V1", + "dual_sg01_adapter_id": "S2A-DUAL-SG01-V1", + "hydration_stability_receipt": dict(hydration_stability_receipt), + "snapshot_start_digest": snapshot_start_digest, + "snapshot_end_digest": snapshot_end_digest, + "snapshot_status": "STABLE", + "input_set_digest": input_set_digest, + } + issue_ledger = _build_issue_ledger( + issues, + normalized_reviews, + run_id=run_id, + input_set_digest=input_set_digest, + ) + status = { + "schema_version": "stage2_s2_00_ingress_status.v1.1", + "run_id": run_id, + "run_binding_receipt": run_binding_receipt, + "route": route, + "executable_cluster_ids": final_executable if route != "TO_S2_40_STATUS_ONLY" else [], + "residual_review_cluster_ids": final_residual, + "issue_codes": issue_codes, + "output_barrier": { + "barrier_id": "S2_00_INGRESS_STATUS_BARRIER", + "barrier_path": "ingress/ingress_status.json", + "publish_semantics": "STATUS_LAST_LOGICAL_COMMIT", + "canonical_output_root": f"stage2_runs/by-binding/{run_binding_digest}/", + "branch": "DIAGNOSTIC" if route == "TO_S2_40_STATUS_ONLY" else "NORMAL", + "artifacts": [], + "artifact_set_digest": canonical_digest([]), + "non_status_artifacts_read_back_verified": True, + "written_last": True, + }, + } + if route == "TO_S2_40_STATUS_ONLY": + artifacts: dict[str, Any] = { + "ingress/stage1_input_manifest.json": manifest, + "ingress/intake_report.json": intake_report, + "ingress/technical_diagnostic.json": { + "schema_version": "stage2_s2_00_technical_diagnostic.v1", + "run_id": run_id, + "route": "TO_S2_40_STATUS_ONLY", + "minimum_coherent_package_possible": False, + "reason_codes": issue_codes or ["MINIMUM_COHERENT_PACKAGE_UNAVAILABLE"], + "source_contract_row_refs": sorted( + set( + ref + for item in issues + for ref in item.get("source_contract_row_refs", []) + ) + ) or ["S2_00"], + "context_published": False, + }, + "review/issue_ledger.base.json": issue_ledger, + "ingress/ingress_status.json": status, + } + else: + artifacts = { + "ingress/stage1_input_manifest.json": manifest, + "ingress/intake_report.json": intake_report, + "context/case_context.json": case_context, + "context/evidence_inventory.json": evidence_inventory, + "context/object_registry.json": object_registry, + "context/party_and_title_context.json": party_context, + "context/slot_crosswalk.json": slot_crosswalk, + "context/cluster_plan.json": cluster_plan, + "context/bundle_plan.json": bundle_plan, + "review/issue_ledger.base.json": issue_ledger, + "ingress/ingress_status.json": status, + } + for cluster_id, slice_body in slices.items(): + if cluster_id in set(final_executable): + artifacts[f"context/cluster_slices/{cluster_id}.json"] = slice_body + publish_receipt = publish_atomically( + output_dir, + artifacts, + run_binding_digest=run_binding_digest, + attempt_id=attempt_id, + stage2_asset_root=asset_root, + ) + return {"route": route, "run_binding_digest": run_binding_digest, "publish": publish_receipt} + + + def _execute_structural_fixture(descriptor_path: Path, release_lock: Mapping[str, Any]) -> dict[str, Any]: + snapshot = open_bounded_snapshot(descriptor_path.parent, descriptor_path.name, logical_input_id="fixture_descriptor") + descriptor = load_json_strict(snapshot) + if not isinstance(descriptor, dict) or descriptor.get("mode") != "STRUCTURAL_FIXTURE": + raise IngressError("FIXTURE_DESCRIPTOR_SHAPE", "fixture descriptor must declare STRUCTURAL_FIXTURE") + if release_lock.get("release_class") != "DEV_FIXTURE_RELEASE": + raise IngressError("FIXTURE_RELEASE_CLASS", "structural fixtures require DEV_FIXTURE_RELEASE") + required = {"fixture_id", "source_locator", "source_hashes", "source_semantics", "expected"} + missing = sorted(required - set(descriptor)) + if missing: + raise IngressError("FIXTURE_DESCRIPTOR_REQUIRED_FIELD", "fixture fields are missing", details={"missing": missing}) + if descriptor.get("source_semantics") not in {"EXPLICIT", "DERIVED"}: + raise IngressError("FIXTURE_SOURCE_SEMANTICS", "source_semantics must be EXPLICIT or DERIVED") + payloads = descriptor.get("fixture_payloads", {}) + source_hashes = descriptor.get("source_hashes", {}) + if not isinstance(payloads, dict) or not isinstance(source_hashes, dict): + raise IngressError("FIXTURE_SOURCE_HASH_SHAPE", "fixture payloads and source hashes must be objects") + for logical_id, payload in payloads.items(): + expected_hash = source_hashes.get(logical_id) + if not isinstance(expected_hash, str) or expected_hash != canonical_digest(payload): + raise IngressError( + "FIXTURE_SOURCE_HASH_MISMATCH", + f"fixture payload hash mismatch for {logical_id}", + ) + return { + "status": "STRUCTURAL_FIXTURE_VALIDATED", + "fixture_id": descriptor["fixture_id"], + "descriptor_sha256": snapshot.raw_sha256, + "canonical_descriptor_sha256": canonical_digest(descriptor), + "published": False, + } + + + def _inline_sha256(value: str, *, code: str) -> str: + if not isinstance(value, str) or re.fullmatch(r"[a-f0-9]{64}", value) is None: + raise IngressError(code, "expected one lowercase SHA-256 digest") + return value + + + def _inline_relative_path(value: str, *, code: str) -> str: + if not isinstance(value, str) or not value or "\x00" in value or "\\" in value: + raise IngressError(code, "logical path is empty or malformed") + if unicodedata.normalize("NFC", value) != value: + raise IngressError(code, "logical path must already be NFC") + path = PurePosixPath(value) + if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts): + raise IngressError(code, "logical path must be a contained relative path") + rendered = path.as_posix() + if rendered != value: + raise IngressError(code, "logical path is not canonical") + return rendered + + + def _inline_join(root: str, relative: str, *, code: str) -> str: + safe_root = _inline_relative_path(root, code=code) + safe_relative = _inline_relative_path(relative, code=code) + return _inline_relative_path(f"{safe_root}/{safe_relative}", code=code) + + + def _inline_parse_mcp_payload(raw: bytes, expected_id: int) -> Mapping[str, Any]: + """Parse one JSON or SSE JSON-RPC terminal response with an exact ID.""" + + candidates: list[Any] + try: + candidates = [load_json_strict(raw)] + except IngressError: + try: + text = raw.decode("utf-8", errors="strict") + except UnicodeDecodeError as exc: + raise IngressError("MCP_RESPONSE_UTF8", "MCP response is not strict UTF-8") from exc + events: list[bytes] = [] + data_lines: list[str] = [] + for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"): + if line == "": + if data_lines: + events.append("\n".join(data_lines).encode("utf-8")) + data_lines = [] + continue + if line.startswith(":") or line.startswith("event:") or line.startswith("id:") or line.startswith("retry:"): + continue + if not line.startswith("data:"): + raise IngressError("MCP_SSE_SHAPE", "unexpected non-data SSE line") + payload = line[5:] + if payload.startswith(" "): + payload = payload[1:] + data_lines.append(payload) + if data_lines: + events.append("\n".join(data_lines).encode("utf-8")) + if not events: + raise IngressError("MCP_RESPONSE_SHAPE", "MCP response contains no JSON terminal event") + candidates = [load_json_strict(event) for event in events] + matching = [ + item + for item in candidates + if isinstance(item, dict) and item.get("id") == expected_id + ] + if len(matching) != 1: + raise IngressError( + "MCP_RESPONSE_ID_MISMATCH", + "MCP response must contain exactly one terminal result with the request ID", + ) + response = matching[0] + if response.get("jsonrpc") != "2.0": + raise IngressError("MCP_JSONRPC_VERSION", "MCP response jsonrpc must equal 2.0") + if response.get("error") is not None: + raise IngressError( + "MCP_JSONRPC_ERROR", + "MCP server returned a JSON-RPC error", + details={"rpc_error": response.get("error")}, + ) + if "result" not in response or not isinstance(response["result"], dict): + raise IngressError("MCP_RESULT_SHAPE", "MCP response result must be an object") + return response + + + def _inline_tool_text(result: Mapping[str, Any], tool_name: str) -> str: + if result.get("isError") is True: + content = result.get("content") + rendered = canonical_json_bytes(content).decode("utf-8", errors="replace") if content is not None else "" + lowered = rendered.lower() + code = ( + "LOCALDOCS_NOT_FOUND" + if any(marker in lowered for marker in ("not found", "does not exist", "no such file")) + else "MCP_TOOL_ERROR" + ) + raise IngressError(code, f"localdocs {tool_name} returned isError=true") + content = result.get("content") + if not isinstance(content, list) or len(content) != 1: + raise IngressError("MCP_CONTENT_CARDINALITY", "MCP tool result must contain exactly one content block") + block = content[0] + if not isinstance(block, dict) or block.get("type") != "text" or not isinstance(block.get("text"), str): + raise IngressError("MCP_CONTENT_SHAPE", "MCP tool result must contain one text block") + return block["text"] + + + def _inline_binary_envelope(text: str, logical_path: str) -> bytes: + value = load_json_strict(text) + if isinstance(value, dict) and "results" in value: + results = value.get("results") + if not isinstance(results, list) or len(results) != 1 or not isinstance(results[0], dict): + raise IngressError("LOCALDOCS_RESULT_CARDINALITY", "binary response must contain one result row") + inner: Any = results[0].get("content", results[0].get("text")) + value = load_json_strict(inner) if isinstance(inner, str) else inner + if not isinstance(value, dict) or not isinstance(value.get("content_base64"), str): + raise IngressError("LOCALDOCS_BINARY_ENVELOPE", "binary response lacks content_base64") + try: + payload = base64.b64decode(value["content_base64"].encode("ascii"), validate=True) + except (UnicodeEncodeError, binascii.Error, ValueError) as exc: + raise IngressError("LOCALDOCS_BASE64_INVALID", "binary response is not strict base64") from exc + declared_size = value.get("byte_length", value.get("size")) + if declared_size is not None and (not isinstance(declared_size, int) or declared_size != len(payload)): + raise IngressError("LOCALDOCS_BYTE_LENGTH_MISMATCH", f"binary length mismatch: {logical_path}") + declared_hash = value.get("sha256") + if declared_hash is not None and declared_hash != hashlib.sha256(payload).hexdigest(): + raise IngressError("LOCALDOCS_HASH_MISMATCH", f"binary hash mismatch: {logical_path}") + return payload + + + class _InlineLocaldocs: + """Minimal user/workspace-bound localdocs JSON-RPC client.""" + + def __init__( + self, + user_hash: str, + workspace_hash: str, + *, + client: Any | None = None, + timeout_seconds: int = 60, + ) -> None: + self.user_hash = _inline_sha256(user_hash, code="USER_CONTEXT_HASH_INVALID") + self.workspace_hash = _inline_sha256( + workspace_hash, + code="WORKSPACE_CONTEXT_HASH_INVALID", + ) + if client is None: + try: + import httpx # type: ignore + except ImportError as exc: + raise IngressError("HTTPX_UNAVAILABLE", "Code Executor must supply httpx==0.28.1") from exc + client = httpx.Client(timeout=timeout_seconds) + self.client = client + self.headers = { + "Content-Type": "application/json", + "Accept": "application/json, text/event-stream", + } + self._message_ids = itertools.count(10) + self._initialized = False + self._session_id: str | None = None + + def close(self) -> None: + close = getattr(self.client, "close", None) + if callable(close): + close() + + def _post(self, body: Mapping[str, Any], expected_id: int | None) -> Mapping[str, Any] | None: + try: + response = self.client.post(LOCALDOCS_URL, json=dict(body), headers=dict(self.headers)) + response.raise_for_status() + except Exception as exc: + raise IngressError("MCP_TRANSPORT_ERROR", "localdocs transport failed") from exc + session_id = response.headers.get("mcp-session-id") + if session_id: + if not isinstance(session_id, str) or not session_id.strip(): + raise IngressError("MCP_SESSION_ID_INVALID", "localdocs returned an invalid session ID") + normalized_session_id = session_id.strip() + if self._session_id is None: + if expected_id != 1: + raise IngressError( + "MCP_SESSION_ID_OUTSIDE_INITIALIZE", + "localdocs first bound a session outside initialize", + ) + self._session_id = normalized_session_id + elif normalized_session_id != self._session_id: + raise IngressError( + "MCP_SESSION_ID_CHANGED", + "localdocs changed the initialized session ID", + ) + self.headers["mcp-session-id"] = self._session_id + if expected_id is None: + return None + raw = response.content if isinstance(response.content, bytes) else bytes(response.content) + return _inline_parse_mcp_payload(raw, expected_id) + + def initialize(self) -> None: + response = self._post( + { + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": MCP_PROTOCOL_VERSION, + "capabilities": {}, + "clientInfo": { + "name": INLINE_CLIENT_NAME, + "version": INLINE_CLIENT_VERSION, + "user_id": self.user_hash, + "workspace_id": self.workspace_hash, + }, + }, + }, + 1, + ) + if response is None: + raise IngressError("MCP_INITIALIZE_EMPTY", "localdocs initialize returned no result") + result = response.get("result") + if not isinstance(result, dict) or result.get("protocolVersion") != MCP_PROTOCOL_VERSION: + raise IngressError( + "MCP_PROTOCOL_VERSION_MISMATCH", + "localdocs did not negotiate the requested MCP protocol version", + ) + if self._session_id is None or "mcp-session-id" not in self.headers: + raise IngressError("MCP_SESSION_ID_MISSING", "localdocs initialize did not bind a session ID") + self._post( + {"jsonrpc": "2.0", "method": "notifications/initialized"}, + None, + ) + self._initialized = True + + def call(self, tool_name: str, arguments: Mapping[str, Any]) -> Mapping[str, Any]: + if not self._initialized: + raise IngressError("MCP_NOT_INITIALIZED", "localdocs session is not initialized") + message_id = next(self._message_ids) + response = self._post( + { + "jsonrpc": "2.0", + "id": message_id, + "method": "tools/call", + "params": {"name": tool_name, "arguments": dict(arguments)}, + }, + message_id, + ) + if response is None: + raise IngressError("MCP_TOOL_EMPTY", f"localdocs {tool_name} returned no result") + return response["result"] + + def read_binary(self, logical_path: str) -> bytes: + path = _inline_relative_path(logical_path, code="LOCALDOCS_READ_PATH_INVALID") + result = self.call("read_binary_doc", {"doc_name": path}) + return _inline_binary_envelope(_inline_tool_text(result, "read_binary_doc"), path) + + def read_binary_optional(self, logical_path: str) -> bytes | None: + try: + return self.read_binary(logical_path) + except IngressError as exc: + if exc.code == "LOCALDOCS_NOT_FOUND": + return None + raise + + def write_binary_verified(self, logical_path: str, payload: bytes) -> str: + path = _inline_relative_path(logical_path, code="LOCALDOCS_WRITE_PATH_INVALID") + encoded = base64.b64encode(payload).decode("ascii") + result = self.call( + "write_binary_file", + {"path": path, "content_base64": encoded, "overwrite": True}, + ) + _inline_tool_text(result, "write_binary_file") + observed = self.read_binary(path) + if observed != payload: + raise IngressError("LOCALDOCS_WRITE_READBACK_MISMATCH", f"read-back mismatch: {path}") + return hashlib.sha256(observed).hexdigest() + + + def _inline_validate_request(raw: bytes) -> dict[str, str]: + value = load_json_strict(raw) + if not isinstance(value, dict): + raise IngressError("RUN_REQUEST_SHAPE", "S2_00 request must be an object") + required = { + "schema_version", + "workflow_id", + "request_id", + "attempt_id", + "stage1_run_root_ref", + "stage1_deployment_root_ref", + } + if set(value) != required: + raise IngressError( + "RUN_REQUEST_CLOSED_SHAPE", + "S2_00 request has missing or unknown keys", + details={"missing": sorted(required - set(value)), "extra": sorted(set(value) - required)}, + ) + if value.get("schema_version") != "stage2_s2_00_execution_request.v1": + raise IngressError("RUN_REQUEST_SCHEMA_VERSION", "unsupported S2_00 request schema") + if value.get("workflow_id") != "S2_00": + raise IngressError("WORKFLOW_ID_MISMATCH", "S2_00 request workflow_id must equal S2_00") + request_id = value.get("request_id") + attempt_id = value.get("attempt_id") + if not isinstance(request_id, str) or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", request_id) is None: + raise IngressError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(attempt_id, str) or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", attempt_id) is None: + raise IngressError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + run_root = _inline_relative_path( + value.get("stage1_run_root_ref"), + code="STAGE1_RUN_ROOT_REF_INVALID", + ) + deployment_root = _inline_relative_path( + value.get("stage1_deployment_root_ref"), + code="STAGE1_DEPLOYMENT_ROOT_REF_INVALID", + ) + return { + "schema_version": value["schema_version"], + "workflow_id": value["workflow_id"], + "request_id": request_id, + "attempt_id": attempt_id, + "stage1_run_root_ref": run_root, + "stage1_deployment_root_ref": deployment_root, + } + + + def _inline_bound_ref(row: Mapping[str, Any], *, code: str) -> tuple[str, str]: + path = _inline_relative_path(row.get("path"), code=code) + digest = _inline_sha256(str(row.get("sha256", "")), code=f"{code}_HASH") + if row.get("binding_status") not in {None, "BOUND"}: + raise IngressError(code, f"asset is not release-bound: {path}") + return path, digest + + + def _inline_release_materialization_plan( + request: Mapping[str, str], + release: Mapping[str, Any], + first_read: Callable[[str], bytes], + ) -> tuple[list[tuple[str, str, str]], dict[str, str]]: + """Return exact remote->temporary destinations and expected remote hashes.""" + + destinations: list[tuple[str, str, str]] = [] + expected_hashes: dict[str, str] = {} + seen_destinations: set[tuple[str, str]] = set() + + def add( + remote_path: str, + local_family: str, + relative_path: str, + *, + expected_sha256: str | None = None, + ) -> None: + remote = _inline_relative_path(remote_path, code="HYDRATION_REMOTE_PATH_INVALID") + relative = _inline_relative_path(relative_path, code="HYDRATION_LOCAL_PATH_INVALID") + key = (local_family, relative) + if key in seen_destinations: + raise IngressError("HYDRATION_DESTINATION_DUPLICATE", f"duplicate hydration destination: {relative}") + seen_destinations.add(key) + destinations.append((remote, local_family, relative)) + if expected_sha256 is not None: + digest = _inline_sha256(expected_sha256.lower(), code="HYDRATION_EXPECTED_HASH_INVALID") + prior = expected_hashes.get(remote) + if prior is not None and prior != digest: + raise IngressError("HYDRATION_HASH_CONFLICT", f"conflicting expected hash: {remote}") + expected_hashes[remote] = digest + + release_remote = INLINE_STAGE2_RELEASE_PATH + add( + release_remote, + "stage2_asset", + "manifest/stage2_release.json", + expected_sha256=EXPECTED_STAGE2_RELEASE_SHA256, + ) + + source_rows = _release_stage1_source_rows(release) + if not isinstance(source_rows, list): + raise IngressError("RELEASE_STAGE1_SOURCE_SHAPE", "release stage1_sources must be an array") + fixed_rows = [row for row in source_rows if row.get("logical_input_id") != "signal_payload_family"] + if len(fixed_rows) != 16: + raise IngressError("RELEASE_STAGE1_SOURCE_COUNT", "release must enumerate exactly 16 fixed inputs") + signal_manifest_relative: str | None = None + for row in fixed_rows: + if not isinstance(row, dict) or not isinstance(row.get("path"), str): + raise IngressError("RELEASE_STAGE1_SOURCE_ROW", "fixed source row lacks an exact path") + relative = _inline_relative_path(row["path"], code="STAGE1_SOURCE_PATH_INVALID") + remote = _inline_join(request["stage1_run_root_ref"], relative, code="STAGE1_SOURCE_PATH_INVALID") + add(remote, "stage1_run", relative) + first_read(remote) + if row.get("logical_input_id") == "signal_manifest": + signal_manifest_relative = relative + if signal_manifest_relative is None: + raise IngressError("SIGNAL_MANIFEST_RELEASE_ROW_MISSING", "release lacks signal_manifest") + signal_remote = _inline_join( + request["stage1_run_root_ref"], + signal_manifest_relative, + code="SIGNAL_MANIFEST_PATH_INVALID", + ) + signal_manifest = load_json_strict(first_read(signal_remote)) + if not isinstance(signal_manifest, dict) or not isinstance(signal_manifest.get("files"), list): + raise IngressError("SIGNAL_FILES_SHAPE", "signal manifest files must be an array") + for index, row in enumerate(signal_manifest["files"]): + if not isinstance(row, dict) or not isinstance(row.get("path"), str): + raise IngressError("SIGNAL_FILE_ROW_SHAPE", f"invalid signal row: {index}") + relative_payload = _inline_relative_path(row["path"], code="SIGNAL_FILE_PATH_INVALID") + if relative_payload.startswith("signals/"): + raise IngressError("SIGNAL_PATH_PREFIX_FORBIDDEN", "signal manifest path includes signals/") + relative = f"signals/{relative_payload}" + remote = _inline_join(request["stage1_run_root_ref"], relative, code="SIGNAL_FILE_PATH_INVALID") + expected = row.get("file_sha256", row.get("sha256", row.get("raw_sha256"))) + add(remote, "stage1_run", relative, expected_sha256=expected if isinstance(expected, str) else None) + first_read(remote) + + dependencies = release.get("dependency_locks") + stage1_dependency = dependencies.get("stage1") if isinstance(dependencies, dict) else None + closure = stage1_dependency.get("concrete_paths") if isinstance(stage1_dependency, dict) else None + if not isinstance(closure, list) or not closure: + raise IngressError("STAGE1_DEPENDENCY_LOCK_MISSING", "Stage 1 deployment closure is absent") + expected_count = stage1_dependency.get("expected_concrete_path_count") + if expected_count is not None and expected_count != len(closure): + raise IngressError("STAGE1_DEPENDENCY_COUNT_MISMATCH", "Stage 1 closure count differs from release") + for row in closure: + if not isinstance(row, dict): + raise IngressError("STAGE1_DEPENDENCY_ROW_SHAPE", "Stage 1 closure row must be an object") + relative, digest = _inline_bound_ref(row, code="STAGE1_DEPENDENCY_UNBOUND") + remote = _inline_join( + request["stage1_deployment_root_ref"], + relative, + code="STAGE1_DEPLOYMENT_PATH_INVALID", + ) + add(remote, "stage1_deployment", relative, expected_sha256=digest) + first_read(remote) + + contract_ref = stage1_dependency.get("contract_manifest_ref", {}) + if isinstance(contract_ref, dict) and isinstance(contract_ref.get("path"), str): + relative, digest = _inline_bound_ref(contract_ref, code="CONTRACT_MANIFEST_UNBOUND") + remote = _inline_join( + request["stage1_deployment_root_ref"], + relative, + code="CONTRACT_MANIFEST_PATH_INVALID", + ) + add(remote, "stage1_deployment", relative, expected_sha256=digest) + first_read(remote) + completion_ref = stage1_dependency.get("completion_seal_ref", {}) + if isinstance(completion_ref, dict) and completion_ref.get("path") not in {None, "PENDING_SEQUENTIAL_BIND"}: + relative, digest = _inline_bound_ref(completion_ref, code="COMPLETION_SEAL_UNBOUND") + remote = _inline_join(request["stage1_run_root_ref"], relative, code="COMPLETION_SEAL_PATH_INVALID") + add(remote, "stage1_run", relative, expected_sha256=digest) + first_read(remote) + + manifest_ref = release.get("module_manifest_ref") + if not isinstance(manifest_ref, dict): + raise IngressError("MODULE_MANIFEST_REF_MISSING", "release lacks module_manifest_ref") + manifest_relative, manifest_digest = _inline_bound_ref(manifest_ref, code="MODULE_MANIFEST_UNBOUND") + manifest_remote = _inline_join(INLINE_STAGE2_ASSET_ROOT, manifest_relative, code="MODULE_MANIFEST_PATH_INVALID") + add(manifest_remote, "stage2_asset", manifest_relative, expected_sha256=manifest_digest) + module_manifest = load_json_strict(first_read(manifest_remote)) + modules = module_manifest.get("modules") if isinstance(module_manifest, dict) else None + if not isinstance(modules, list): + raise IngressError("MODULE_MANIFEST_SHAPE", "module manifest lacks modules array") + found_schema_ids: set[str] = set() + for row in modules: + if not isinstance(row, dict) or row.get("module_id") not in INLINE_SCHEMA_MODULE_IDS: + continue + relative, digest = _inline_bound_ref(row, code="STAGE2_SCHEMA_UNBOUND") + remote = _inline_join(INLINE_STAGE2_ASSET_ROOT, relative, code="STAGE2_SCHEMA_PATH_INVALID") + add(remote, "stage2_asset", relative, expected_sha256=digest) + first_read(remote) + found_schema_ids.add(str(row["module_id"])) + if found_schema_ids != set(INLINE_SCHEMA_MODULE_IDS): + raise IngressError( + "STAGE2_SCHEMA_CLOSURE_INCOMPLETE", + "module manifest does not bind all S2_00 schemas", + details={"missing": sorted(set(INLINE_SCHEMA_MODULE_IDS) - found_schema_ids)}, + ) + + stage2_direct = dependencies.get("stage2_direct") if isinstance(dependencies, dict) else None + if not isinstance(stage2_direct, list): + raise IngressError("STAGE2_DIRECT_LOCK_MISSING", "release lacks Stage 2 direct closure") + for row in stage2_direct: + if not isinstance(row, dict): + raise IngressError("STAGE2_DIRECT_ROW_SHAPE", "Stage 2 direct row must be an object") + relative, digest = _inline_bound_ref(row, code="STAGE2_DIRECT_UNBOUND") + remote = _inline_join(INLINE_STAGE2_ASSET_ROOT, relative, code="STAGE2_DIRECT_PATH_INVALID") + add(remote, "stage2_asset", relative, expected_sha256=digest) + first_read(remote) + return destinations, expected_hashes + + + def _inline_hydrate( + localdocs: _InlineLocaldocs, + temp_root: Path, + ) -> tuple[dict[str, str], Mapping[str, Any], Path, Path, Path, dict[str, Any]]: + first_pass: dict[str, bytes] = {} + first_pass_bytes = 0 + + request_raw = localdocs.read_binary(INLINE_REQUEST_PATH) + if len(request_raw) > MAX_FILE_BYTES: + raise IngressError("SOURCE_SIZE_LIMIT", "S2_00 request exceeds the global pre-parse file limit") + first_pass[INLINE_REQUEST_PATH] = request_raw + first_pass_bytes += len(request_raw) + request = _inline_validate_request(request_raw) + + release_raw = localdocs.read_binary(INLINE_STAGE2_RELEASE_PATH) + if len(release_raw) > MAX_FILE_BYTES: + raise IngressError("SOURCE_SIZE_LIMIT", "Stage 2 release exceeds the global pre-parse file limit") + first_pass[INLINE_STAGE2_RELEASE_PATH] = release_raw + first_pass_bytes += len(release_raw) + if first_pass_bytes > MAX_RUN_BYTES: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "initial request and release exceed the global pre-parse budget") + if EXPECTED_STAGE2_RELEASE_SHA256 == "0" * 64: + raise IngressError( + "EXPECTED_STAGE2_RELEASE_SHA256_UNBOUND", + "build-time Stage 2 release pin has not been bound", + ) + expected_release = _inline_sha256( + EXPECTED_STAGE2_RELEASE_SHA256, + code="EXPECTED_STAGE2_RELEASE_SHA256_INVALID", + ) + if hashlib.sha256(release_raw).hexdigest() != expected_release: + raise IngressError("STAGE2_RELEASE_PIN_MISMATCH", "Stage 2 release bytes differ from the build-time pin") + release = load_json_strict(release_raw) + if not isinstance(release, dict): + raise IngressError("RELEASE_LOCK_SHAPE", "Stage 2 release must be an object") + limits = release.get("limits") if isinstance(release.get("limits"), dict) else {} + max_file = int(limits.get("max_file_bytes", MAX_FILE_BYTES)) + max_total = int(limits.get("max_run_bytes", MAX_RUN_BYTES)) + max_paths = int(limits.get("max_hydration_paths", 1024)) + if max_file <= 0 or max_file > MAX_FILE_BYTES: + raise IngressError("RELEASE_FILE_LIMIT_INVALID", "release max_file_bytes exceeds the build-time ceiling") + if max_total <= 0 or max_total > MAX_RUN_BYTES: + raise IngressError("RELEASE_RUN_LIMIT_INVALID", "release max_run_bytes exceeds the build-time ceiling") + if max_paths <= 0 or max_paths > 1024: + raise IngressError("RELEASE_PATH_LIMIT_INVALID", "release max_hydration_paths exceeds the build-time ceiling") + if len(request_raw) > max_file or len(release_raw) > max_file: + raise IngressError("SOURCE_SIZE_LIMIT", "initial request or release exceeds the release-bound file limit") + if first_pass_bytes > max_total: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "initial request and release exceed the release-bound budget") + + def first_read(path: str) -> bytes: + nonlocal first_pass_bytes + safe = _inline_relative_path(path, code="HYDRATION_REMOTE_PATH_INVALID") + if safe not in first_pass: + payload = localdocs.read_binary(safe) + if len(payload) > max_file: + raise IngressError("SOURCE_SIZE_LIMIT", f"remote source exceeds file limit: {safe}") + first_pass_bytes += len(payload) + if first_pass_bytes > max_total: + raise IngressError("AGGREGATE_RUN_SIZE_LIMIT", "first-pass hydration exceeds release budget") + first_pass[safe] = payload + return first_pass[safe] + + destinations, expected_hashes = _inline_release_materialization_plan( + request, + release, + first_read, + ) + if len(first_pass) > max_paths: + raise IngressError("HYDRATION_PATH_COUNT_LIMIT", "hydration path count exceeds release budget") + for remote, expected in expected_hashes.items(): + observed = hashlib.sha256(first_read(remote)).hexdigest() + if observed != expected: + raise IngressError("HYDRATION_BOUND_HASH_MISMATCH", f"release-bound hash mismatch: {remote}") + + second_pass_bytes = 0 + second_pass: dict[str, bytes] = {} + for remote in sorted(first_pass): + payload = localdocs.read_binary(remote) + second_pass_bytes += len(payload) + if len(payload) > max_file or second_pass_bytes > max_total: + raise IngressError("TWO_PASS_READ_BUDGET", "second-pass hydration exceeds release budget") + if payload != first_pass[remote] or hashlib.sha256(payload).digest() != hashlib.sha256(first_pass[remote]).digest(): + raise IngressError("SOURCE_SNAPSHOT_CHANGED", f"remote source changed between bounded reads: {remote}") + second_pass[remote] = payload + + pass_1_hash_rows = [ + [path, hashlib.sha256(first_pass[path]).hexdigest()] + for path in sorted(first_pass) + ] + pass_2_hash_rows = [ + [path, hashlib.sha256(second_pass[path]).hexdigest()] + for path in sorted(second_pass) + ] + hydration_receipt = { + "schema_version": "stage2_s2_00_two_pass_hydration_receipt.v1", + "transport": "localdocs.read_binary_doc", + "read_policy": "BOUNDED_TWO_PASS_BINARY_RAW_HASH_MAP_EQUALITY", + "read_pass_count": 2, + "max_read_passes": 2, + "pass_1_raw_hash_map_digest": canonical_digest(pass_1_hash_rows), + "pass_2_raw_hash_map_digest": canonical_digest(pass_2_hash_rows), + "source_receipts": [ + { + "logical_input_id": path, + "logical_path": path, + "pass_1_raw_sha256": hashlib.sha256(first_pass[path]).hexdigest(), + "pass_2_raw_sha256": hashlib.sha256(second_pass[path]).hexdigest(), + "pass_1_byte_length": len(first_pass[path]), + "pass_2_byte_length": len(second_pass[path]), + "stability_status": "STABLE", + } + for path in sorted(first_pass) + ], + "stability_status": "STABLE", + } + + roots = { + "stage1_run": temp_root / "stage1_run", + "stage1_deployment": temp_root / "stage1_deployment", + "stage2_asset": temp_root / "stage2_asset", + } + for root in roots.values(): + root.mkdir(parents=True, exist_ok=False) + for remote, family, relative in sorted(destinations): + target = roots[family] / PurePosixPath(relative) + target.parent.mkdir(parents=True, exist_ok=True) + if target.exists(): + raise IngressError("HYDRATION_DESTINATION_EXISTS", f"duplicate materialization: {relative}") + target.write_bytes(first_pass[remote]) + return ( + request, + release, + roots["stage1_run"], + roots["stage1_deployment"], + roots["stage2_asset"], + hydration_receipt, + ) + + + def _inline_output_files(output_root: Path, run_binding_digest: str) -> dict[str, bytes]: + if not output_root.is_dir() or output_root.is_symlink(): + raise IngressError("LOCAL_OUTPUT_TREE_MISSING", "pure core did not produce an output tree") + files: dict[str, bytes] = {} + for path in sorted(output_root.rglob("*")): + if path.is_symlink(): + raise IngressError("LOCAL_OUTPUT_SYMLINK", "pure core output contains a symlink") + if not path.is_file(): + continue + relative = _safe_relative_path(path.relative_to(output_root).as_posix()).as_posix() + files[relative] = path.read_bytes() + status_raw = files.get("ingress/ingress_status.json") + if status_raw is None: + raise IngressError("OUTPUT_BARRIER_MISSING", "pure core output lacks ingress_status") + status = load_json_strict(status_raw) + binding = status.get("run_binding_receipt") if isinstance(status, dict) else None + if not isinstance(binding, dict) or binding.get("run_binding_digest") != run_binding_digest: + raise IngressError("RUN_BINDING_RECEIPT_MISMATCH", "pure core status has a different binding") + barrier = status.get("output_barrier") + rows = barrier.get("artifacts") if isinstance(barrier, dict) else None + if not isinstance(rows, list) or barrier.get("written_last") is not True: + raise IngressError("OUTPUT_BARRIER_INVALID", "pure core output barrier is incomplete") + expected_paths = {"ingress/ingress_status.json"} + for row in rows: + if not isinstance(row, dict) or not isinstance(row.get("path"), str): + raise IngressError("OUTPUT_BARRIER_ROW_SHAPE", "output barrier row is malformed") + relative = _safe_relative_path(row["path"]).as_posix() + payload = files.get(relative) + if payload is None or hashlib.sha256(payload).hexdigest() != row.get("raw_sha256"): + raise IngressError("OUTPUT_BARRIER_HASH_MISMATCH", f"output barrier mismatch: {relative}") + expected_paths.add(relative) + if set(files) != expected_paths: + raise IngressError("OUTPUT_BARRIER_SET_MISMATCH", "output tree differs from its barrier set") + if barrier.get("artifact_set_digest") != canonical_digest(rows): + raise IngressError("OUTPUT_BARRIER_DIGEST_MISMATCH", "output barrier row digest is invalid") + return files + + + def _inline_verify_existing_remote( + localdocs: _InlineLocaldocs, + output_root: str, + files: Mapping[str, bytes], + run_binding_digest: str, + ) -> bool: + status_path = _inline_join(output_root, "ingress/ingress_status.json", code="OUTPUT_PATH_INVALID") + status_raw = localdocs.read_binary_optional(status_path) + if status_raw is None: + return False + status = load_json_strict(status_raw) + binding = status.get("run_binding_receipt") if isinstance(status, dict) else None + if not isinstance(binding, dict) or binding.get("run_binding_digest") != run_binding_digest: + raise IngressError("RUN_ID_BINDING_CONFLICT", "existing remote barrier has a different binding") + if status_raw != files.get("ingress/ingress_status.json"): + raise IngressError("IDEMPOTENT_STATUS_MISMATCH", "existing remote status is not byte-identical") + for relative, expected in sorted(files.items()): + observed = localdocs.read_binary(_inline_join(output_root, relative, code="OUTPUT_PATH_INVALID")) + if observed != expected: + raise IngressError("IDEMPOTENT_ARTIFACT_MISMATCH", f"existing artifact differs: {relative}") + return True + + + def _inline_publish_remote( + localdocs: _InlineLocaldocs, + files: Mapping[str, bytes], + run_binding_digest: str, + ) -> dict[str, Any]: + output_root = f"stage2_runs/by-binding/{run_binding_digest}" + status_raw = files["ingress/ingress_status.json"] + status = load_json_strict(status_raw) + barrier = status.get("output_barrier") if isinstance(status, dict) else None + branch = barrier.get("branch") if isinstance(barrier, dict) else None + if branch not in {"NORMAL", "DIAGNOSTIC"}: + raise IngressError("OUTPUT_BARRIER_BRANCH_INVALID", "pure core output barrier lacks a valid branch") + artifact_rows = [ + { + "logical_artifact_id": relative, + "path": relative, + "schema_id": _output_schema_id(relative), + "raw_sha256": hashlib.sha256(payload).hexdigest(), + "byte_length": len(payload), + } + for relative, payload in sorted(files.items()) + if relative != "ingress/ingress_status.json" + ] + if _inline_verify_existing_remote(localdocs, output_root, files, run_binding_digest): + publication_status = "IDEMPOTENT_SUCCESS" + else: + for relative in sorted(path for path in files if path != "ingress/ingress_status.json"): + localdocs.write_binary_verified( + _inline_join(output_root, relative, code="OUTPUT_PATH_INVALID"), + files[relative], + ) + status_path = _inline_join(output_root, "ingress/ingress_status.json", code="OUTPUT_PATH_INVALID") + localdocs.write_binary_verified(status_path, status_raw) + if localdocs.read_binary(status_path) != status_raw: + raise IngressError("OUTPUT_BARRIER_READBACK_MISMATCH", "remote ingress_status read-back failed") + publication_status = "PUBLISHED_STATUS_LAST" + return { + "schema_version": "stage2_logical_publish_receipt.v1", + "barrier_id": "S2_00_INGRESS_STATUS_BARRIER", + "barrier_path": "ingress/ingress_status.json", + "publish_semantics": "STATUS_LAST_LOGICAL_COMMIT", + "canonical_output_root": f"{output_root}/", + "run_binding_digest": run_binding_digest, + "branch": branch, + "artifacts": artifact_rows, + "artifact_set_digest": canonical_digest(artifact_rows), + "barrier_raw_sha256": hashlib.sha256(status_raw).hexdigest(), + "non_status_artifacts_read_back_verified": True, + "barrier_written_last": True, + "downstream_consumption_allowed": True, + "publication_status": publication_status, + } + + + def _inline_context_is_bound() -> bool: + return ( + re.fullmatch(r"[a-f0-9]{64}", INLINE_USER_HASH) is not None + and re.fullmatch(r"[a-f0-9]{64}", INLINE_WORKSPACE_HASH) is not None + ) + + + def run_inline_mcp(*, client: Any | None = None) -> int: + """Execute one complete MCP Code Executor S2_00 task and emit one JSON receipt.""" + + localdocs: _InlineLocaldocs | None = None + receipt: dict[str, Any] + exit_code = 0 + try: + with contextlib.redirect_stdout(io.StringIO()): + localdocs = _InlineLocaldocs( + INLINE_USER_HASH, + INLINE_WORKSPACE_HASH, + client=client, + ) + try: + localdocs.initialize() + with tempfile.TemporaryDirectory(prefix="liti-s2-00-") as directory: + temp_root = Path(directory) + ( + request, + _release, + stage1_root, + deployment_root, + asset_root, + hydration_receipt, + ) = _inline_hydrate(localdocs, temp_root) + release_lock = load_release_lock(asset_root / "manifest" / "stage2_release.json") + contract_manifest = _load_bound_contract_manifest(deployment_root, release_lock) + local_output = temp_root / "core_output" + result = execute_ingress( + stage1_root, + release_lock, + output_dir=local_output, + attempt_id=request["attempt_id"], + run_id=request["request_id"], + user_context_sha256=INLINE_USER_HASH, + workspace_context_sha256=INLINE_WORKSPACE_HASH, + stage1_deployment_root=deployment_root, + stage2_asset_root=asset_root, + contract_manifest=contract_manifest, + hydration_stability_receipt=hydration_receipt, + ) + run_binding_digest = _inline_sha256( + str(result.get("run_binding_digest", "")), + code="CORE_RUN_BINDING_INVALID", + ) + files = _inline_output_files(local_output, run_binding_digest) + publication = _inline_publish_remote(localdocs, files, run_binding_digest) + receipt = { + "schema_version": "stage2_s2_00_inner_receipt.v1", + "workflow_id": "S2_00", + "ok": True, + "status": ( + "DIAGNOSTIC_PUBLISHED" + if result["route"] == "TO_S2_40_STATUS_ONLY" + else "SUCCEEDED" + ), + "request_id": request["request_id"], + "route": result["route"], + "run_id": canonical_run_id(run_binding_digest), + "run_binding_digest": run_binding_digest, + "expected_release_sha256": EXPECTED_STAGE2_RELEASE_SHA256, + "algorithm_digest": ALGORITHM_SEMANTIC_DIGEST, + "artifact_set_digest": publication["artifact_set_digest"], + "ingress_status_sha256": publication["barrier_raw_sha256"], + "logical_publish_receipt": publication, + } + finally: + if localdocs is not None: + localdocs.close() + except Exception as exc: + error = ( + exc.as_dict() + if isinstance(exc, IngressError) + else {"code": "INLINE_RUNTIME_ERROR", "message": str(exc)} + ) + receipt = { + "schema_version": "stage2_s2_00_inner_receipt.v1", + "workflow_id": "S2_00", + "ok": False, + "status": "FAILED_NO_BARRIER", + "expected_release_sha256": EXPECTED_STAGE2_RELEASE_SHA256, + "error": error, + } + exit_code = 2 + sys.stdout.buffer.write(canonical_json_bytes(receipt)) + return exit_code + + + class _FixedArgvParser(argparse.ArgumentParser): + def error(self, message: str) -> None: + raise IngressError("CLI_ARGUMENT_ERROR", message) + + + def _parser() -> argparse.ArgumentParser: + parser = _FixedArgvParser( + description="S2_00 deterministic Stage 1 ingress", + add_help=False, + ) + parser.add_argument("--workflow-id", required=True) + parser.add_argument("--release-ref", required=True) + parser.add_argument("--run-id", required=True) + parser.add_argument("--attempt-id", required=True) + parser.add_argument("--user-context-sha256", required=True) + parser.add_argument("--workspace-context-sha256", required=True) + parser.add_argument("--stage1-run-root-ref", required=True) + parser.add_argument("--stage1-deployment-root-ref", required=True) + return parser + + + def _project_root_from_runtime() -> Path: + for candidate in Path(__file__).resolve().parents: + if candidate.name == "Case_02_Comparison_Research": + return candidate + raise IngressError("PROJECT_ROOT_NOT_FOUND", "runtime is not located below the canonical project root") + + + def _resolve_contained_ref( + approved_root: Path, + ref: str, + *, + code: str, + ) -> Path: + if not isinstance(ref, str) or not ref or "\x00" in ref: + raise IngressError(code, "workspace reference is empty or malformed") + candidate = Path(ref) + if not candidate.is_absolute(): + candidate = approved_root / candidate + if candidate.is_symlink(): + raise IngressError(code, "workspace reference may not be a symlink") + approved_resolved = approved_root.resolve(strict=True) + try: + lexical_relative = candidate.relative_to(approved_root) + except ValueError: + lexical_relative = None + if lexical_relative is not None: + _assert_no_symlink_components(approved_resolved, PurePosixPath(lexical_relative.as_posix())) + resolved = candidate.resolve(strict=True) + try: + resolved.relative_to(approved_resolved) + except ValueError as exc: + raise IngressError(code, "workspace reference escaped its approved root") from exc + return resolved + + + def _load_bound_contract_manifest( + stage1_deployment_root: Path, + release_lock: Mapping[str, Any], + ) -> Mapping[str, Any] | None: + dependency = release_lock.get("dependency_locks", {}).get("stage1", {}) + ref = dependency.get("contract_manifest_ref", {}) if isinstance(dependency, dict) else {} + if not isinstance(ref, dict) or not isinstance(ref.get("path"), str): + return None + expected_hash = ref.get("sha256") + if not isinstance(expected_hash, str) or not re.fullmatch(r"[A-Fa-f0-9]{64}", expected_hash): + raise IngressError("CONTRACT_MANIFEST_UNBOUND", "contract manifest hash is not bound") + snapshot = open_bounded_snapshot( + stage1_deployment_root, + ref["path"], + logical_input_id="stage1_contract_manifest", + ) + if snapshot.raw_sha256 != expected_hash: + raise IngressError("CONTRACT_MANIFEST_HASH_MISMATCH", "contract manifest raw hash differs from release") + value = load_json_strict(snapshot) + if not isinstance(value, dict): + raise IngressError("CONTRACT_MANIFEST_SHAPE", "contract manifest must be an object") + return value + + + def main(argv: Sequence[str] | None = None) -> int: + """CLI entrypoint. Stdout contains exactly one canonical JSON object.""" + + try: + args = _parser().parse_args(argv) + if args.workflow_id != "S2_00": + raise IngressError("WORKFLOW_ID_MISMATCH", "runtime accepts only workflow_id S2_00") + asset_root = Path(__file__).resolve().parents[1] + project_root = _project_root_from_runtime() + release_path = _resolve_contained_ref(asset_root, args.release_ref, code="RELEASE_REF_OUTSIDE_ROOT") + if not release_path.is_file(): + raise IngressError("RELEASE_REF_NOT_FILE", "release reference must identify one regular file") + stage1_run_root = _resolve_contained_ref( + project_root, + args.stage1_run_root_ref, + code="STAGE1_RUN_ROOT_OUTSIDE_WORKSPACE", + ) + stage1_deployment_root = _resolve_contained_ref( + project_root, + args.stage1_deployment_root_ref, + code="STAGE1_DEPLOYMENT_ROOT_OUTSIDE_WORKSPACE", + ) + if not stage1_run_root.is_dir() or not stage1_deployment_root.is_dir(): + raise IngressError("STAGE1_ROOT_NOT_DIRECTORY", "Stage 1 roots must be directories") + release_lock = load_release_lock(release_path) + contract_manifest = _load_bound_contract_manifest(stage1_deployment_root, release_lock) + output_dir = project_root / "stage2_runs" / args.run_id + result = execute_ingress( + stage1_run_root, + release_lock, + output_dir=output_dir, + attempt_id=args.attempt_id, + run_id=args.run_id, + user_context_sha256=args.user_context_sha256, + workspace_context_sha256=args.workspace_context_sha256, + stage1_deployment_root=stage1_deployment_root, + stage2_asset_root=asset_root, + contract_manifest=contract_manifest, + ) + sys.stdout.buffer.write(canonical_json_bytes({"ok": True, "result": result})) + return 0 + except (IngressError, FileNotFoundError, PermissionError, OSError) as exc: + error = exc.as_dict() if isinstance(exc, IngressError) else {"code": "OS_ERROR", "message": str(exc)} + sys.stdout.buffer.write(canonical_json_bytes({"ok": False, "error": error})) + return 2 + + + if __name__ == "__main__": + raise SystemExit(run_inline_mcp()) + task_procedure: + IN: + nexts: + - Task_S2_00_deterministic_ingress + wait_until: [] + Task_S2_00_deterministic_ingress: + nexts: + - OUT + wait_until: + - IN + OUT: + nexts: [] + wait_until: + - Task_S2_00_deterministic_ingress diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml index eb547a7e..b5b3bdeb 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml @@ -71,7 +71,7 @@ Agent: WORKFLOW_ID = "S2_20" ALGORITHM_VERSION = "s2_20_relief_plan/1.0.0" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" WEAVIATE_MCP_URL = "https://weaviate.eroomai.com/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_30.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_30.yml index 55c36d46..85d73661 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_30.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_30.yml @@ -73,7 +73,7 @@ Agent: from typing import Any, Mapping - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml index 57d65722..366d3c1f 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml @@ -68,7 +68,7 @@ Agent: WORKFLOW_ID = "S2_40" ALGORITHM_VERSION = "s2_40_finalizer/1.0.0" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml index 821c3e3c..369d0f2f 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml @@ -9,30 +9,42 @@ stage_bindings: agent_script_ref: asset_id: AGENT-S2_00-INLINE path: agent_scripts/Stage_2_S2_00.yml - sha256: 94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943 + sha256: 07bc9e235d211f3d4e6886bca2faeeb1f112d525fa29fe111bd7c50c42ff9849 schema_id: liti_agent_yaml.v1 binding_status: BOUND workflow_contract_ref: asset_id: WF-S2_00 path: workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml - sha256: 3d7ceb86b236668c8c372136f1d1b43a5d0a79d3fb05fd1ef4342bb638190f68 + sha256: 9b606ef4ddc7859591d9455fd9cdf9dfe6ad2533824636deb727b82e035f503a schema_id: stage2_workflow_contract.v1.2 binding_status: BOUND inline_code_receipt_ref: asset_id: RECEIPT-S2_00-INLINE-CODE path: manifest/s2_00_inline_code_receipt.json - sha256: 36af21949e5ef53a3d39df8ea9491c64da43abcc4f5e42e13db9bb391da843b8 + sha256: be044ab40ee86e7c3a1be6c421b2c5d36ee67fc2fd2870f59a3d9d911fef6c1a schema_id: stage2_s2_00_inline_code_receipt.v2 binding_status: BOUND stage2_release_ref: asset_id: RELEASE-STAGE2-CLEAN path: manifest/stage2_release.json - sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 + sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 schema_id: stage2_release.v2 binding_status: BOUND - expected_release_sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 - agent_script_sha256: 94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943 - canonical_code_sha256: e3f87725d5a6496189e7c411ef940dd8a7b3a9ff5b00535803bf98fa0cc4373e + expected_release_sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 + agent_script_sha256: 07bc9e235d211f3d4e6886bca2faeeb1f112d525fa29fe111bd7c50c42ff9849 + canonical_code_sha256: 81e619b26560890f9a4066e4275f2f51e63910d7983ba453230d4dd6e90bfd6a + prepare_request_contract: + task_name: Task_S2_00_prepare_request + yaml_pointer: /Agent/Stages/0/tasks/0/parameters/code + required_external_arguments: + - request_id + - attempt_id + - stage1_run_root_ref + - stage1_deployment_root_ref + write_path: stage2_control/s2_00_request.json + argument_binding_status: UNVERIFIED + success_gate_status: UNVERIFIED + workspace_serialization_status: UNVERIFIED mcp_server_id: code-executor tool_name: run_code language: python @@ -86,7 +98,7 @@ stage_bindings: agent_script_ref: asset_id: AGENT-S2_20-INLINE path: agent_scripts/Stage_2_S2_20.yml - sha256: 3c4e6a7404f5b6a6b2403824c3cd9e71db566d4f2865bd4de3e6fd9d07824bd6 + sha256: eb82f84df10c1eb4402e5e0f87fbe97a12e58aaa04f60c9535d66076300a5fdb schema_id: liti_agent_yaml.v1 binding_status: BOUND workflow_contract_ref: @@ -98,18 +110,18 @@ stage_bindings: inline_code_receipt_ref: asset_id: RECEIPT-S2_20-INLINE-CODE path: manifest/s2_20_inline_code_receipt.json - sha256: 65e29f10f065cdd77281aa47acaf341edb38b0595aab0aa9f04bbee3a4718608 + sha256: 64fd3711bd1128b6d29d3b8ff7a6af07228764da9604e0b5506562c5420e83e9 schema_id: stage2_s2_20_inline_code_receipt.v1 binding_status: BOUND stage2_release_ref: asset_id: RELEASE-STAGE2-CLEAN path: manifest/stage2_release.json - sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 + sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 schema_id: stage2_release.v2 binding_status: BOUND - expected_release_sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 - agent_script_sha256: 3c4e6a7404f5b6a6b2403824c3cd9e71db566d4f2865bd4de3e6fd9d07824bd6 - canonical_code_sha256: 6f1f503378242cf64cf8f0838af2164ab1103bc7031c8a6873f4ee89be66f7fd + expected_release_sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 + agent_script_sha256: eb82f84df10c1eb4402e5e0f87fbe97a12e58aaa04f60c9535d66076300a5fdb + canonical_code_sha256: 91feb9e2ced624a2a4ea36e2b83bd17ed20bb059a42206fad01660800adeb515 mcp_server_id: code-executor tool_name: run_code language: python @@ -237,7 +249,7 @@ stage_bindings: agent_script_ref: asset_id: AGENT-S2_40-INLINE path: agent_scripts/Stage_2_S2_40.yml - sha256: 5cbe2ac9aa73d95a5fa4e6cf71d7d8f0ad83aa05536f573c13e42505ef5d46f7 + sha256: a628f7fe944e21f77b9276cdb3d048189dcec958c7ed5abdcd9638b53a909a68 schema_id: liti_agent_yaml.v1 binding_status: BOUND workflow_contract_ref: @@ -249,18 +261,18 @@ stage_bindings: inline_code_receipt_ref: asset_id: RECEIPT-S2_40-INLINE-CODE path: manifest/s2_40_inline_code_receipt.json - sha256: 9bd0cfaee8d9e78480ab80a2fa541414c7ad0565439fa0f4661701fcdfde6526 + sha256: 38fa1f5d8fc930ee3f7bbff7c73e1a52efc4995d14126ae035323ff74f1abf3d schema_id: stage2_s2_40_inline_code_receipt.v1 binding_status: BOUND stage2_release_ref: asset_id: RELEASE-STAGE2-CLEAN path: manifest/stage2_release.json - sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 + sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 schema_id: stage2_release.v2 binding_status: BOUND - expected_release_sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 - agent_script_sha256: 5cbe2ac9aa73d95a5fa4e6cf71d7d8f0ad83aa05536f573c13e42505ef5d46f7 - canonical_code_sha256: e521e1a65294a769cd6bf20edb159f8720c105b60cb769885aa416c8c763dcef + expected_release_sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 + agent_script_sha256: a628f7fe944e21f77b9276cdb3d048189dcec958c7ed5abdcd9638b53a909a68 + canonical_code_sha256: 12f6b83e1e6793ad871033c6e6b840fc1e31f9fb6695b1a15f0406978fe841f7 mcp_server_id: code-executor tool_name: run_code language: python @@ -323,7 +335,7 @@ embedded_task_bindings: agent_script_ref: asset_id: AGENT-S2_30-INLINE path: agent_scripts/Stage_2_S2_30.yml - sha256: d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd + sha256: 8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3 schema_id: liti_agent_yaml.v1 binding_status: BOUND workflow_contract_ref: @@ -335,18 +347,18 @@ embedded_task_bindings: inline_code_receipt_ref: asset_id: RECEIPT-S2_30-INLINE-CODE path: manifest/s2_30_inline_code_receipt.json - sha256: 8d1618771cf1f72aa3c6a5a4544fe6b6e949ccc7ecfef56f166561971beee896 + sha256: a5e4e3161fc16f3e44ec9ae2c05d2c4706eca02099d844520973f76475343998 schema_id: stage2_s2_30_inline_code_receipt.v1 binding_status: BOUND stage2_release_ref: asset_id: RELEASE-STAGE2-CLEAN path: manifest/stage2_release.json - sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 + sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 schema_id: stage2_release.v2 binding_status: BOUND - expected_release_sha256: 9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53 - agent_script_sha256: d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd - canonical_code_sha256: 1f7f3b842afbd3f1034f094d6341288effc9804a03920ada4bf8cfd512464e4c + expected_release_sha256: 2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590 + agent_script_sha256: 8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3 + canonical_code_sha256: 17e66a89befdeb3ac4d7901eda2dad57869db809baf5faf16434cd7a7adb067a mcp_server_id: code-executor tool_name: run_code language: python diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_s2_30_llm_binding.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_s2_30_llm_binding.yml index 6a447ce4..6d7fab7a 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_s2_30_llm_binding.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/deployment/stage2_s2_30_llm_binding.yml @@ -2,7 +2,7 @@ schema_version: stage2_s2_30_llm_binding.v1 binding_status: PENDING_EXTERNAL_PLATFORM_BINDING agent_ref: path: agent_scripts/Stage_2_S2_30.yml - sha256: d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd + sha256: 8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3 workflow_ref: path: workflows/S2_30_claim_group_draft_map.yml sha256: b266e7b7ae8939b087bfdb7b34fff8b9c6011c835560ab690991d856ced0cc15 @@ -13,7 +13,7 @@ schema_ref: size_bytes: 68470 planner_ref: path: runtime/s2_30_dispatch_planner.py - sha256: 1f7f3b842afbd3f1034f094d6341288effc9804a03920ada4bf8cfd512464e4c + sha256: 17e66a89befdeb3ac4d7901eda2dad57869db809baf5faf16434cd7a7adb067a model: provider: openai model_id: gpt-5.6-sol @@ -30,10 +30,10 @@ prompt_contract: - S30 inline_common_prompt_sha256: a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0 inline_static_prompt_sha256: 577efa2c3334298ec60188b9f0066f834e072dc99f785b3c6ab4d05a47fac18a - projection_receipt_sha256: 1aa650d3c389ba27ce43e514295c7c2ce629583dc96220618fd97dea399d0757 + projection_receipt_sha256: 00b66f3495de5d1ff1e6e508eae2939cf862fdfc799c9cd01544a7979f769c42 runtime_external_prompt_read_allowed: false planner_contract: - inline_code_receipt_sha256: 8d1618771cf1f72aa3c6a5a4544fe6b6e949ccc7ecfef56f166561971beee896 + inline_code_receipt_sha256: a5e4e3161fc16f3e44ec9ae2c05d2c4706eca02099d844520973f76475343998 legal_reasoning_allowed: false persistent_write_allowed: false native_adapter: diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/module_manifest.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/module_manifest.json index a037cc14..9b9f2463 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/module_manifest.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/module_manifest.json @@ -1 +1 @@ -{"closure_summary":{"build_tool_module_count":1,"cycle_breaking_contract":"AGENT_CODE_RECEIPT_AND_EXECUTOR_BINDING_EXTERNALLY_BIND_RELEASE_RAW_HASH","documentation_mirror_count":57,"executable_agent_hash_included":false,"executor_binding_hash_included":false,"fixture_closure_ref":"tests/fixtures/regression_manifest.json","fixture_descriptor_count":60,"generic_module_counts_by_stage":{"S2_20":90,"S2_30":26,"S2_40":30},"inline_runtime_code_hash_included":false,"module_count":222,"profile_module_count":45,"prompt_module_count":2,"runtime_code_hash_included":false,"s2_20_generic_module_count":90,"s2_30_generic_module_count":26,"s2_40_generic_module_count":30,"self_hash_included":false,"stage2_release_hash_included":false,"test_module_count":72},"documentation_mirrors":[{"byte_identical":true,"mirror_path":"offline_build/build_authority_law_value_release.txt","mirror_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","mirror_size_bytes":7213,"runtime_import_allowed":false,"source_path":"offline_build/build_authority_law_value_release.py","source_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","source_size_bytes":7213},{"byte_identical":true,"mirror_path":"offline_build/build_corpus_snapshot.txt","mirror_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","mirror_size_bytes":9781,"runtime_import_allowed":false,"source_path":"offline_build/build_corpus_snapshot.py","source_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","source_size_bytes":9781},{"byte_identical":true,"mirror_path":"offline_build/build_release_manifests.txt","mirror_sha256":"9356d18267375e731e878ab301dcec01a728d73761df0dd65829599c00ccfcd5","mirror_size_bytes":30698,"runtime_import_allowed":false,"source_path":"offline_build/build_release_manifests.py","source_sha256":"9356d18267375e731e878ab301dcec01a728d73761df0dd65829599c00ccfcd5","source_size_bytes":30698},{"byte_identical":true,"mirror_path":"offline_build/build_s2_00_inline_projection.txt","mirror_sha256":"31c96b6abe2eb0ed1f9c9e571e1f4f326307225dfddf40a6670e2d3073ed2ab4","mirror_size_bytes":35198,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_00_inline_projection.py","source_sha256":"31c96b6abe2eb0ed1f9c9e571e1f4f326307225dfddf40a6670e2d3073ed2ab4","source_size_bytes":35198},{"byte_identical":true,"mirror_path":"offline_build/build_s2_10_agent_projection.txt","mirror_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","mirror_size_bytes":68381,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_10_agent_projection.py","source_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","source_size_bytes":68381},{"byte_identical":true,"mirror_path":"offline_build/build_s2_20_inline_projection.txt","mirror_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","mirror_size_bytes":27865,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_20_inline_projection.py","source_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","source_size_bytes":27865},{"byte_identical":true,"mirror_path":"offline_build/build_s2_30_agent_projection.txt","mirror_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","mirror_size_bytes":56585,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_30_agent_projection.py","source_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","source_size_bytes":56585},{"byte_identical":true,"mirror_path":"offline_build/build_s2_40_inline_projection.txt","mirror_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","mirror_size_bytes":36098,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_40_inline_projection.py","source_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","source_size_bytes":36098},{"byte_identical":true,"mirror_path":"offline_build/compile_case_type_registry.txt","mirror_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","mirror_size_bytes":9658,"runtime_import_allowed":false,"source_path":"offline_build/compile_case_type_registry.py","source_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","source_size_bytes":9658},{"byte_identical":true,"mirror_path":"offline_build/compile_relief_rule_projection.txt","mirror_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","mirror_size_bytes":42682,"runtime_import_allowed":false,"source_path":"offline_build/compile_relief_rule_projection.py","source_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","source_size_bytes":42682},{"byte_identical":true,"mirror_path":"offline_build/validate_s2_10_contract.txt","mirror_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","mirror_size_bytes":63811,"runtime_import_allowed":false,"source_path":"offline_build/validate_s2_10_contract.py","source_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","source_size_bytes":63811},{"byte_identical":true,"mirror_path":"offline_build/validate_s2_30_contract.txt","mirror_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","mirror_size_bytes":104292,"runtime_import_allowed":false,"source_path":"offline_build/validate_s2_30_contract.py","source_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","source_size_bytes":104292},{"byte_identical":true,"mirror_path":"release_ops/canary_rollback.txt","mirror_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","mirror_size_bytes":1345,"runtime_import_allowed":false,"source_path":"release_ops/canary_rollback.py","source_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","source_size_bytes":1345},{"byte_identical":true,"mirror_path":"release_ops/release_validator.txt","mirror_sha256":"5c962c0ca084ce08a622764c874749bd837534b7b0a3af4ba9f879b975a0f866","mirror_size_bytes":55260,"runtime_import_allowed":false,"source_path":"release_ops/release_validator.py","source_sha256":"5c962c0ca084ce08a622764c874749bd837534b7b0a3af4ba9f879b975a0f866","source_size_bytes":55260},{"byte_identical":true,"mirror_path":"runtime/authority/authority_preflight.txt","mirror_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","mirror_size_bytes":2115,"runtime_import_allowed":false,"source_path":"runtime/authority/authority_preflight.py","source_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","source_size_bytes":2115},{"byte_identical":true,"mirror_path":"runtime/binding_signature_projection.txt","mirror_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","mirror_size_bytes":5843,"runtime_import_allowed":false,"source_path":"runtime/binding_signature_projection.py","source_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","source_size_bytes":5843},{"byte_identical":true,"mirror_path":"runtime/c25_case_type_bind.txt","mirror_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","mirror_size_bytes":3471,"runtime_import_allowed":false,"source_path":"runtime/c25_case_type_bind.py","source_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","source_size_bytes":3471},{"byte_identical":true,"mirror_path":"runtime/c26_rule_branch_bind.txt","mirror_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","mirror_size_bytes":5089,"runtime_import_allowed":false,"source_path":"runtime/c26_rule_branch_bind.py","source_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","source_size_bytes":5089},{"byte_identical":true,"mirror_path":"runtime/c27_query_plan.txt","mirror_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","mirror_size_bytes":6553,"runtime_import_allowed":false,"source_path":"runtime/c27_query_plan.py","source_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","source_size_bytes":6553},{"byte_identical":true,"mirror_path":"runtime/c28_weaviate_retrieve.txt","mirror_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","mirror_size_bytes":12083,"runtime_import_allowed":false,"source_path":"runtime/c28_weaviate_retrieve.py","source_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","source_size_bytes":12083},{"byte_identical":true,"mirror_path":"runtime/c29_pack_verify.txt","mirror_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","mirror_size_bytes":5721,"runtime_import_allowed":false,"source_path":"runtime/c29_pack_verify.py","source_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","source_size_bytes":5721},{"byte_identical":true,"mirror_path":"runtime/c45_document_assembler.txt","mirror_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","mirror_size_bytes":11992,"runtime_import_allowed":false,"source_path":"runtime/c45_document_assembler.py","source_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","source_size_bytes":11992},{"byte_identical":true,"mirror_path":"runtime/calculators/registry_engine.txt","mirror_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","mirror_size_bytes":11417,"runtime_import_allowed":false,"source_path":"runtime/calculators/registry_engine.py","source_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","source_size_bytes":11417},{"byte_identical":true,"mirror_path":"runtime/rendering/closed_renderer.txt","mirror_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","mirror_size_bytes":10559,"runtime_import_allowed":false,"source_path":"runtime/rendering/closed_renderer.py","source_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","source_size_bytes":10559},{"byte_identical":true,"mirror_path":"runtime/validation/invariant_runner.txt","mirror_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","mirror_size_bytes":30951,"runtime_import_allowed":false,"source_path":"runtime/validation/invariant_runner.py","source_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","source_size_bytes":30951},{"byte_identical":true,"mirror_path":"tests/s2_00/test_canonical_ids.txt","mirror_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","mirror_size_bytes":2275,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_canonical_ids.py","source_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","source_size_bytes":2275},{"byte_identical":true,"mirror_path":"tests/s2_00/test_cluster_bundle_compile.txt","mirror_sha256":"b643d2d4018ebe3349c64304063edf7ba0194fc92fb1fe9337eca3f384ae794a","mirror_size_bytes":25690,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_cluster_bundle_compile.py","source_sha256":"b643d2d4018ebe3349c64304063edf7ba0194fc92fb1fe9337eca3f384ae794a","source_size_bytes":25690},{"byte_identical":true,"mirror_path":"tests/s2_00/test_conservation.txt","mirror_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","mirror_size_bytes":5562,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_conservation.py","source_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","source_size_bytes":5562},{"byte_identical":true,"mirror_path":"tests/s2_00/test_failure_and_atomic_publish.txt","mirror_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","mirror_size_bytes":25937,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_failure_and_atomic_publish.py","source_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","source_size_bytes":25937},{"byte_identical":true,"mirror_path":"tests/s2_00/test_inline_code_parity.txt","mirror_sha256":"8f0f55e8e1b970de572129946ab8bf34967c7fd84e316a9193509cab07a455ed","mirror_size_bytes":15928,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_inline_code_parity.py","source_sha256":"8f0f55e8e1b970de572129946ab8bf34967c7fd84e316a9193509cab07a455ed","source_size_bytes":15928},{"byte_identical":true,"mirror_path":"tests/s2_00/test_resolver_source_lock.txt","mirror_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","mirror_size_bytes":14423,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_resolver_source_lock.py","source_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","source_size_bytes":14423},{"byte_identical":true,"mirror_path":"tests/s2_00/test_schema_hash_and_signals.txt","mirror_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","mirror_size_bytes":12842,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_schema_hash_and_signals.py","source_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","source_size_bytes":12842},{"byte_identical":true,"mirror_path":"tests/s2_10/test_agent_contract.txt","mirror_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","mirror_size_bytes":8076,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_agent_contract.py","source_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","source_size_bytes":8076},{"byte_identical":true,"mirror_path":"tests/s2_10/test_domain_verdict_contract.txt","mirror_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","mirror_size_bytes":10242,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_domain_verdict_contract.py","source_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","source_size_bytes":10242},{"byte_identical":true,"mirror_path":"tests/s2_10/test_prompt_cache_and_boundaries.txt","mirror_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","mirror_size_bytes":11365,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_prompt_cache_and_boundaries.py","source_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","source_size_bytes":11365},{"byte_identical":true,"mirror_path":"tests/s2_10/test_release_adapter_retry.txt","mirror_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","mirror_size_bytes":10848,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_release_adapter_retry.py","source_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","source_size_bytes":10848},{"byte_identical":true,"mirror_path":"tests/s2_10/test_wave_dispatch.txt","mirror_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","mirror_size_bytes":9894,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_wave_dispatch.py","source_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","source_size_bytes":9894},{"byte_identical":true,"mirror_path":"tests/s2_20/test_agent_and_inline_parity.txt","mirror_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","mirror_size_bytes":2773,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_agent_and_inline_parity.py","source_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","source_size_bytes":2773},{"byte_identical":true,"mirror_path":"tests/s2_20/test_calculation_and_reports.txt","mirror_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","mirror_size_bytes":3199,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_calculation_and_reports.py","source_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","source_size_bytes":3199},{"byte_identical":true,"mirror_path":"tests/s2_20/test_inline_output_schema.txt","mirror_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","mirror_size_bytes":43574,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_inline_output_schema.py","source_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","source_size_bytes":43574},{"byte_identical":true,"mirror_path":"tests/s2_20/test_offline_compilers.txt","mirror_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","mirror_size_bytes":20252,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_offline_compilers.py","source_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","source_size_bytes":20252},{"byte_identical":true,"mirror_path":"tests/s2_20/test_option_group_and_binding.txt","mirror_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","mirror_size_bytes":6171,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_option_group_and_binding.py","source_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","source_size_bytes":6171},{"byte_identical":true,"mirror_path":"tests/s2_20/test_plan_publish_and_release.txt","mirror_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","mirror_size_bytes":13950,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_plan_publish_and_release.py","source_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","source_size_bytes":13950},{"byte_identical":true,"mirror_path":"tests/s2_20/test_regression_manifest_closure.txt","mirror_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","mirror_size_bytes":10028,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_regression_manifest_closure.py","source_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","source_size_bytes":10028},{"byte_identical":true,"mirror_path":"tests/s2_20/test_retrieval_and_pack.txt","mirror_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","mirror_size_bytes":6654,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_retrieval_and_pack.py","source_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","source_size_bytes":6654},{"byte_identical":true,"mirror_path":"tests/s2_30/test_agent_contract.txt","mirror_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","mirror_size_bytes":12199,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_agent_contract.py","source_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","source_size_bytes":12199},{"byte_identical":true,"mirror_path":"tests/s2_30/test_dispatch_materialization.txt","mirror_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","mirror_size_bytes":13911,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_dispatch_materialization.py","source_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","source_size_bytes":13911},{"byte_identical":true,"mirror_path":"tests/s2_30/test_draft_atom_contract.txt","mirror_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","mirror_size_bytes":10484,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_draft_atom_contract.py","source_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","source_size_bytes":10484},{"byte_identical":true,"mirror_path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","mirror_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","mirror_size_bytes":6284,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_prompt_cache_and_boundaries.py","source_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","source_size_bytes":6284},{"byte_identical":true,"mirror_path":"tests/s2_30/test_release_adapter_retry.txt","mirror_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","mirror_size_bytes":18566,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_release_adapter_retry.py","source_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","source_size_bytes":18566},{"byte_identical":true,"mirror_path":"tests/s2_40/test_agent_and_inline_parity.txt","mirror_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","mirror_size_bytes":32947,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_agent_and_inline_parity.py","source_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","source_size_bytes":32947},{"byte_identical":true,"mirror_path":"tests/s2_40/test_c40_reduce_and_conservation.txt","mirror_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","mirror_size_bytes":3032,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_c40_reduce_and_conservation.py","source_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","source_size_bytes":3032},{"byte_identical":true,"mirror_path":"tests/s2_40/test_c45_closed_render.txt","mirror_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","mirror_size_bytes":7855,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_c45_closed_render.py","source_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","source_size_bytes":7855},{"byte_identical":true,"mirror_path":"tests/s2_40/test_commit_barrier_and_idempotence.txt","mirror_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","mirror_size_bytes":8228,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_commit_barrier_and_idempotence.py","source_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","source_size_bytes":8228},{"byte_identical":true,"mirror_path":"tests/s2_40/test_release_closure.txt","mirror_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","mirror_size_bytes":12692,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_release_closure.py","source_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","source_size_bytes":12692},{"byte_identical":true,"mirror_path":"tests/s2_40/test_review_state_machine.txt","mirror_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","mirror_size_bytes":8373,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_review_state_machine.py","source_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","source_size_bytes":8373},{"byte_identical":true,"mirror_path":"tests/s2_40/test_v01_v18.txt","mirror_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","mirror_size_bytes":3853,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_v01_v18.py","source_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","source_size_bytes":3853}],"forbidden_contract_registry":[{"code":"LEGACY-STAGE2-V0-V3","legacy_runtime_dependency_allowed":false,"meaning":"The clean S2_00 workflow and runtime must not read or execute legacy Stage 2 v.0-v.3 specifications."},{"code":"LEGACY-STAGE2-LOADER","legacy_runtime_dependency_allowed":false,"meaning":"The historical host loader and loader binding are reference-only and cannot authorize, execute, or provide fallback for S2_00."},{"code":"RAW-STAGE1-REREAD","legacy_runtime_dependency_allowed":false,"meaning":"S2_10 must consume immutable bounded cluster projections and must not rediscover raw Stage 1 inputs."},{"code":"S2_40-PLEADING-RENDER-IN-STATUS-ONLY","legacy_runtime_dependency_allowed":false,"meaning":"The S2_40 status-only entrypoint must not render or commit pleading text."}],"implementation_status":"OFFLINE_HYBRID_RESEAL_COMPLETE_LIVE_ADMISSION_PENDING","manifest_digest":"6fda5bad6b43cedd593c7066ea0e6565dfd55457377b26035b594adfb85db266","manifest_digest_contract":{"algorithm_id":"STAGE2-MODULE-MANIFEST-DIGEST-V1","array_order":"PRESERVE_DECLARED_ORDER","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","digest_algorithm":"sha256","digest_scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_MANIFEST_DIGEST","encoding":"UTF-8","line_termination":"LF_ONE_TRAILING_NEWLINE","non_finite_numbers_allowed":false,"object_key_order":"SORT_CODEPOINT","verification_status":"DEV_VERIFIED"},"manifest_id":"STAGE2-CLEAN-S2_00-STRUCTURED-HANDOFF-V2-INLINE","manifest_scope":"S2_00_STRUCTURED_CONTEXT_HANDOFF_AND_SHARED_CONTRACTS","manifest_status":"DEV_HASH_BOUND_DOWNSTREAM_HYBRID_RELEASE_PENDING","modules":[{"asset_version":"s2_00.1.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json","https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-INGRESS","SCHEMA-CONTEXT","SCHEMA-REVIEW-STATUS"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"IMPLEMENTED_DECLARATIVE_CONTRACT","incompatible_module_ids":[],"inputs":["STAGE1-ALLOWLIST-V1","STAGE1-DEPLOYMENT-CLOSURE-2026-08-29"],"module_id":"WF-S2_00","module_kind":"WORKFLOW","outputs":["S2_00-NORMAL-BRANCH","S2_00-DIAGNOSTIC-BRANCH"],"owner":"Stage_2_workflow_maintainer","path":"workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml","produced_schema_ids":[],"schema_version":"stage2_workflow_contract.v1.2","scope_predicate":"workflow_id == S2_00","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"3d7ceb86b236668c8c372136f1d1b43a5d0a79d3fb05fd1ef4342bb638190f68","size_bytes":17351},{"asset_version":"s2_00.schema.1.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-INGRESS","module_kind":"JSON_SCHEMA","outputs":["INGRESS-SCHEMA-DEFS"],"owner":"Stage_2_schema_owner","path":"schemas/ingress.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json"],"schema_version":"stage2_s2_00_ingress.v1.1","scope_predicate":"artifact_family == ingress","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"8fd7b76015b7d7dfbbe056e08999dda7ea8e1012bb16cec50634b08f7ea97302","size_bytes":33444},{"asset_version":"s2_00.schema.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-REVIEW-STATUS"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-CONTEXT","module_kind":"JSON_SCHEMA","outputs":["CONTEXT-SCHEMA-DEFS"],"owner":"Stage_2_schema_owner","path":"schemas/context.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json"],"schema_version":"stage2_s2_00_context.v2","scope_predicate":"artifact_family == context","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"29073ffa847d74304228d61306503c0c3798da7db8b5717b1ad6d5b2da98aa92","size_bytes":39054},{"asset_version":"stage2.shared.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-DEPLOYMENT","module_kind":"JSON_SCHEMA","outputs":["DEPLOYMENT-SCHEMA-DEFS"],"owner":"Stage_2_deployment_schema_owner","path":"schemas/deployment.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"schema_version":"stage2_deployment.v2","scope_predicate":"artifact_family == deployment","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"a4e76d674c0fcc3afb2f99c35fbdbfdde0c6ee6a6e2be63ed26470e5d5c7d003","size_bytes":92638},{"asset_version":"stage2.shared.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-REVIEW-STATUS","module_kind":"JSON_SCHEMA","outputs":["REVIEW-STATUS-SCHEMA-DEFS"],"owner":"Stage_2_review_schema_owner","path":"schemas/review_status.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"schema_version":"stage2_review_status.v1","scope_predicate":"artifact_family == review_status","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"dbf559cae183b9e9878a56ff9364ddfe68f7bf6ba1e00e595ec8876f2fc01d95","size_bytes":27241},{"asset_version":"stage2.cache.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-CONTEXT"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["RELEASE-SELECTED-CONTEXT-ORDERED-REFS","S2_00-COHORT-MEMBERSHIP","S2_00-MEMBER-SLICE-REF-SET"],"module_id":"CACHE-POLICY-STRUCTURED-CONTEXT-HANDOFF","module_kind":"CACHE_POLICY","outputs":["S2_00-CONTEXT-MATERIALIZATION-RECEIPT","S2_10-CACHE-IDENTITY-INPUT"],"owner":"Stage_2_cache_policy_owner","path":"registry/cache/prompt_cache_policy.yml","produced_schema_ids":[],"schema_version":"stage2_prompt_cache_policy.v2","scope_predicate":"consumer == S2_10","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"32b638073b721a9f395d3476105e57236be4e076be81fd6e93f1475b29b93e2a","size_bytes":7527},{"asset_version":"s2_00.test.1.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"module_id":"REGRESSION-MANIFEST-S2_00","module_kind":"TEST_MANIFEST","outputs":["FIXTURE-RESULT-DIGEST"],"owner":"Stage_2_regression_owner","path":"tests/fixtures/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_00_regression_manifest.v1","scope_predicate":"workflow_id == S2_00","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"734b70ab4ae7ef5b4d65129ae33eef1677b647fadacbafb479f64fae1978c0ac","size_bytes":58019},{"asset_version":"s2_40.finalizer.1","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json","https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_10/s2_10.schema.v2.json","https://schemas.liti-agent.local/stage2/s2_20/binding_retrieval.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_20/calculation.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_20/relief_plan.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_30/draft_atoms.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_40/package.schema.v1.json","https://schemas.liti-agent.local/stage2/shared/deployment.schema.v3.json","https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-CONTEXT","SCHEMA-DEPLOYMENT","SCHEMA-INGRESS","SCHEMA-REVIEW-STATUS","SCHEMA-S2_10","S2_20-ASSET-809C3C709B4F2295","S2_20-ASSET-AA40CF5140DE8790","S2_20-ASSET-C9FC917D8CBF920E","S2_20-ASSET-E82839694073D431","S2_20-ASSET-FF1F03B3FC56E579","S2_30-ASSET-6A9B1F5EC854740E","S2_30-ASSET-E1FCF8BD63300F4D","S2_40-ASSET-5C4CAFFAB8D2F982","WF-S2_00","WF-S2_10"],"entry_routes":["TO_S2_40","TO_S2_40_STATUS_ONLY"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","S2_40-DIRECTORY-SCAN","S2_40-FREE-TEXT-RENDER-FALLBACK","S2_40-LLM-CALL","S2_40-RUN-STATUS-NOT-LAST","S2_40-UNVERIFIED-READY"],"implementation_status":"IMPLEMENTED_OFFLINE_CONTRACT_LIVE_ADMISSION_PENDING","incompatible_module_ids":[],"inputs":["ingress/ingress_status.json","ingress/technical_diagnostic.json","ingress/stage1_input_manifest.json","ingress/intake_report.json","review/issue_ledger.base.json","map_s2_10/s2_10_publish_status.json","plan/plan_publish_status.json","plan/canonical_relief_plan.json","plan/claim_groups.json","plan/case_type_bindings.json","map_s2_30/s2_30_publish_status.json","map_s2_30/artifact_manifest.json","map_s2_30/{draft_parts,issue_patches,worknote_parts,usage_parts}/.json","review/review_receipts/.json","review/lawyer_judgment_record.json"],"legal_admission_status":"PENDING","live_admission_status":"PENDING","module_id":"WF-S2_40","module_kind":"WORKFLOW","outputs":["review/issue_ledger.final.json","review/assumption_ledger.json","review/llm_usage.jsonl","candidates/by-content-digest//","review/review_requests/.json","final/claim_relief.md","final/claim_cause.md","final/pleading_draft.md","final/stage2_package.json","commit/commit_intent.json","commit/stage2_commit_result.json","control/run_status.json"],"owner":"Stage_2_S2_40_owner","path":"workflows/S2_40_final_review_render_and_commit.yml","produced_schema_ids":["stage2_s2_40_candidate_manifest.v1","stage2_s2_40_commit_intent.v1","stage2_s2_40_commit_result.v1","stage2_s2_40_package.v1","stage2_s2_40_run_status.v1"],"schema_version":"stage2_workflow_contract.v1","scope_predicate":"workflow_id == S2_40 and entry_route in {TO_S2_40,TO_S2_40_STATUS_ONLY}","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ab1e5f593db41c1f26f9510c00d657221da53d08f011b2c4cf341a764a18d874","size_bytes":4415,"status_only_exact_inputs":["ingress/ingress_status.json","ingress/technical_diagnostic.json","ingress/stage1_input_manifest.json","ingress/intake_report.json","review/issue_ledger.base.json"]},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_resolver_source_lock.txt","mirror_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","mirror_size_bytes":14423,"module_id":"TEST-S2_00-RESOLVER-SOURCE-LOCK","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_resolver_source_lock.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == resolver_source_lock","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","size_bytes":14423},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_schema_hash_and_signals.txt","mirror_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","mirror_size_bytes":12842,"module_id":"TEST-S2_00-SCHEMA-HASH-SIGNALS","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_schema_hash_and_signals.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == schema_hash_signals","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","size_bytes":12842},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_conservation.txt","mirror_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","mirror_size_bytes":5562,"module_id":"TEST-S2_00-CONSERVATION","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_conservation.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == conservation","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","size_bytes":5562},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_canonical_ids.txt","mirror_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","mirror_size_bytes":2275,"module_id":"TEST-S2_00-CANONICAL-IDS","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_canonical_ids.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == canonical_ids","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","size_bytes":2275},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_cluster_bundle_compile.txt","mirror_sha256":"b643d2d4018ebe3349c64304063edf7ba0194fc92fb1fe9337eca3f384ae794a","mirror_size_bytes":25690,"module_id":"TEST-S2_00-CLUSTER-BUNDLE","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_cluster_bundle_compile.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == cluster_bundle_compile","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"b643d2d4018ebe3349c64304063edf7ba0194fc92fb1fe9337eca3f384ae794a","size_bytes":25690},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_failure_and_atomic_publish.txt","mirror_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","mirror_size_bytes":25937,"module_id":"TEST-S2_00-FAILURE-ATOMIC-PUBLISH","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_failure_and_atomic_publish.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == failure_atomic_publish","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","size_bytes":25937},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"P00","module_kind":"LLM_PROMPT_CONTRACT","outputs":["STATIC_PREFIX_SEGMENT"],"owner":"Stage_2_prompt_owner","path":"prompts/P00_system_and_safety_contract.md","produced_schema_ids":[],"schema_version":"stage2.prompt_contract.v1","scope_predicate":"static_prefix_segment == P00","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P00"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P00"],"module_id":"P10","module_kind":"LLM_PROMPT_CONTRACT","outputs":["STATIC_PREFIX_SEGMENT"],"owner":"Stage_2_prompt_owner","path":"prompts/P10_legal_resolution_contract.md","produced_schema_ids":[],"schema_version":"stage2.prompt_contract.v1","scope_predicate":"static_prefix_segment == P10","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"cafaab3991b8bd4ef3c95e55ce4c0649794c6eed9479d46d8c7758a4b823569b","size_bytes":8712},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-EC-00_CONTRACT_GENERAL","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/EC-00_contract_general.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/EC-00_contract_general.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8","size_bytes":3789},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-01_JURISTIC_ACT_VALIDITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-01_juristic_act_validity.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-01_juristic_act_validity.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99","size_bytes":3808},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-02_CONTRACT_MONEY_CLAIM","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-02_contract_money_claim.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-02_contract_money_claim.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824","size_bytes":3784},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-03_PARTIES_LIABILITY_SUCCESSION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-03_parties_liability_succession.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-03_parties_liability_succession.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c","size_bytes":3799},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-04_UNJUST_ENRICHMENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-04_unjust_enrichment.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-04_unjust_enrichment.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7","size_bytes":3725},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-05_TORT_GENERAL","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-05_tort_general.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-05_tort_general.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a","size_bytes":3694},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-06_PROFESSIONAL_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-06_professional_liability.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-06_professional_liability.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15","size_bytes":3724},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-07_CONSTRUCTION_DEFECT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-07_construction_defect.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-07_construction_defect.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9","size_bytes":3710},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-08_LEASE_DEPOSIT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-08_lease_deposit.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-08_lease_deposit.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db","size_bytes":3678},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-09_REGISTRY_TRANSFER_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-09_registry_transfer_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-09_registry_transfer_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002","size_bytes":3800},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-10_SECURED_REGISTRY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-10_secured_registry.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-10_secured_registry.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba","size_bytes":3757},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-11_POSSESSION_VINDICATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-11_possession_vindication.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-11_possession_vindication.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf","size_bytes":3724},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-12_CO_OWNERSHIP_BOUNDARY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-12_co_ownership_boundary.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-12_co_ownership_boundary.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a","size_bytes":3712},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-13_CREDITOR_PRESERVATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-13_creditor_preservation.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-13_creditor_preservation.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45","size_bytes":3826},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-14_EXECUTION_LINKED_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-14_execution_linked_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-14_execution_linked_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7","size_bytes":3787},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-15_SUCCESSION_FAMILY_PROPERTY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-15_succession_family_property.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-15_succession_family_property.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766","size_bytes":3763},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-16_NEGOTIABLE_INSTRUMENTS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-16_negotiable_instruments.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-16_negotiable_instruments.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194","size_bytes":3738},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-17_LABOR_WAGE_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-17_labor_wage_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-17_labor_wage_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea","size_bytes":3728},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-18_ORG_RESOLUTION_STATUS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-18_org_resolution_status.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-18_org_resolution_status.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f","size_bytes":3763},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-19_INSURANCE_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-19_insurance_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-19_insurance_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c","size_bytes":3685},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-20_IP_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-20_ip_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-20_ip_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1","size_bytes":3654},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-21_MEDIA_PERSONALITY_RIGHTS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-21_media_personality_rights.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-21_media_personality_rights.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c","size_bytes":3803},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-00_RESIDUAL_UNROUTED","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/E-00_residual_unrouted.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/E-00_residual_unrouted.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39","size_bytes":3752},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X1_NOTICE_LIFECYCLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X1_notice_lifecycle.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X1_notice_lifecycle.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef","size_bytes":3693},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X2_ASSET_IDENTITY_LINEAGE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X2_asset_identity_lineage.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X2_asset_identity_lineage.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad","size_bytes":3742},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X3_PROCEDURE_STANDING_RELIEF","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X3_procedure_standing_relief.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X3_procedure_standing_relief.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df","size_bytes":3788},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X4_RESPONSE_ADMISSION_DEFENSE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X4_response_admission_defense.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X4_response_admission_defense.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e","size_bytes":3793},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-AUTO_MOTOR_VEHICLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-AUTO_motor_vehicle.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91","size_bytes":3762},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-INDUSTRIAL_ACCIDENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f","size_bytes":3750},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-PRODUCT_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-PRODUCT_LIABILITY.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53","size_bytes":3737},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-RESIDENTIAL_LEASE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-RESIDENTIAL_LEASE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7","size_bytes":3739},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-COMMERCIAL_LEASE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-COMMERCIAL_LEASE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e","size_bytes":3769},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-LABOR","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-LABOR.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-LABOR.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a","size_bytes":3694},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-STATE_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-STATE_LIABILITY.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-STATE_LIABILITY.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3","size_bytes":3747},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-PATENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-PATENT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-PATENT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066","size_bytes":3709},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-COPYRIGHT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-COPYRIGHT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-COPYRIGHT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78","size_bytes":3728},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-OTHER","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-OTHER.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-OTHER.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8","size_bytes":3746},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-MEDIA","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-MEDIA.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-MEDIA.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c","size_bytes":3705},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-TRANSPORT_MARITIME","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-TRANSPORT_MARITIME.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456","size_bytes":3835},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-CONSUMER_CONTRACT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-CONSUMER_CONTRACT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7","size_bytes":3797},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-MORTGAGE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-MORTGAGE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-MORTGAGE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d","size_bytes":3739},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-MORTGAGE-CREATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee","size_bytes":3771},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-ENCUMBERED-TRANSFER","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179","size_bytes":3828},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-PRESERVED-CLAIM-BUNDLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5","size_bytes":3816},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-DEFENSE-MAP","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-DEFENSE-MAP.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191","size_bytes":3810},{"asset_version":"s2_00.build.1.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"dependency_module_ids":["SCHEMA-DEPLOYMENT"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":["AUTHORING-AGENT-YAML"],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_00_inline_projection.txt","mirror_sha256":"31c96b6abe2eb0ed1f9c9e571e1f4f326307225dfddf40a6670e2d3073ed2ab4","mirror_size_bytes":35198,"module_id":"BUILD-S2_00-INLINE-PROJECTION","module_kind":"BUILD_TOOL","outputs":["DEPLOYMENT-AGENT-PROJECTION","FULL-CODE-MIRRORS","INLINE-CODE-RECEIPT"],"owner":"Stage_2_release_build_owner","path":"offline_build/build_s2_00_inline_projection.py","produced_schema_ids":["stage2_s2_00_inline_code_receipt.v2"],"schema_version":"offline_projection_builder.v1","scope_predicate":"build_target == S2_00_INLINE_AGENT","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"31c96b6abe2eb0ed1f9c9e571e1f4f326307225dfddf40a6670e2d3073ed2ab4","size_bytes":35198},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"dependency_module_ids":["BUILD-S2_00-INLINE-PROJECTION","SCHEMA-DEPLOYMENT","WF-S2_00"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["AUTHORING-AGENT-YAML","DEPLOYMENT-AGENT-PROJECTION","FULL-CODE-MIRRORS"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_inline_code_parity.txt","mirror_sha256":"8f0f55e8e1b970de572129946ab8bf34967c7fd84e316a9193509cab07a455ed","mirror_size_bytes":15928,"module_id":"TEST-S2_00-INLINE-CODE-PARITY","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_inline_code_parity.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == inline_code_parity","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"8f0f55e8e1b970de572129946ab8bf34967c7fd84e316a9193509cab07a455ed","size_bytes":15928},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"WF-S2_10","module_kind":"WORKFLOW","outputs":["WF-S2_10"],"owner":"Stage_2_S2_10_owner","path":"workflows/S2_10_domain_relief_resolution_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["WF-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"AGENT-S2_10-HYBRID","module_kind":"LLM_AGENT","outputs":["AGENT-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"agent_scripts/Stage_2_S2_10.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"SCHEMA-S2_10","module_kind":"JSON_SCHEMA","outputs":["SCHEMA-S2_10"],"owner":"Stage_2_S2_10_owner","path":"schemas/s2_10.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["AGENT-S2_10-HYBRID","SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"BINDING-S2_10-HYBRID","module_kind":"DEPLOYMENT_BINDING","outputs":["BINDING-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"deployment/stage2_s2_10_llm_binding.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","size_bytes":7287},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["AGENT-S2_10-HYBRID","P00","P10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"PROMPT-PROJECTION-S2_10","module_kind":"BUILD_RECEIPT","outputs":["PROMPT-PROJECTION-S2_10"],"owner":"Stage_2_S2_10_owner","path":"manifest/s2_10_inline_prompt_projection_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_10_agent_projection.txt","mirror_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","mirror_size_bytes":68381,"module_id":"BUILD-S2_10-HYBRID","module_kind":"BUILD_ONLY","outputs":["BUILD-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"offline_build/build_s2_10_agent_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"offline_build/validate_s2_10_contract.txt","mirror_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","mirror_size_bytes":63811,"module_id":"VALIDATOR-S2_10","module_kind":"BUILD_ONLY","outputs":["VALIDATOR-S2_10"],"owner":"Stage_2_S2_10_owner","path":"offline_build/validate_s2_10_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_agent_contract.txt","mirror_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","mirror_size_bytes":8076,"module_id":"TEST-S2_10-AGENT","module_kind":"TEST","outputs":["TEST-S2_10-AGENT"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_agent_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","size_bytes":8076},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_wave_dispatch.txt","mirror_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","mirror_size_bytes":9894,"module_id":"TEST-S2_10-DISPATCH","module_kind":"TEST","outputs":["TEST-S2_10-DISPATCH"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_wave_dispatch.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","size_bytes":9894},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10","VALIDATOR-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_domain_verdict_contract.txt","mirror_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","mirror_size_bytes":10242,"module_id":"TEST-S2_10-DOMAIN","module_kind":"TEST","outputs":["TEST-S2_10-DOMAIN"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_domain_verdict_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","size_bytes":10242},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["PROMPT-PROJECTION-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_prompt_cache_and_boundaries.txt","mirror_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","mirror_size_bytes":11365,"module_id":"TEST-S2_10-PROMPT","module_kind":"TEST","outputs":["TEST-S2_10-PROMPT"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_prompt_cache_and_boundaries.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","size_bytes":11365},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["BINDING-S2_10-HYBRID"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_release_adapter_retry.txt","mirror_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","mirror_size_bytes":10848,"module_id":"TEST-S2_10-RELEASE","module_kind":"TEST","outputs":["TEST-S2_10-RELEASE"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_release_adapter_retry.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","size_bytes":10848},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"REGRESSION-MANIFEST-S2_10","module_kind":"TEST_MANIFEST","outputs":["REGRESSION-MANIFEST-S2_10"],"owner":"Stage_2_S2_10_owner","path":"tests/fixtures/s2_10/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6fe7bac0fb2b87e4ff3535c9bfa78531aff91af4cc1142a09035225b95581e3d","size_bytes":2572},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-F82ABBC2137A8ABF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/build_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"57fbf8c3f5f86f00db668c425c3e07de74e9d5820b71975c4da3a3bff32e036d","size_bytes":1871},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-F8EF2F640FB77AD1","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/chunk_manifest.jsonl","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"fd3e1ba067b5960e1d3dba1b5107de913d45ba2b3732a28c3870b10105761b67","size_bytes":620},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-787106ABBFAF8931","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/source_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ce3ce207ed274292499630a0813d4bdb6a66baf26710fb0e883c2e405adb9a67","size_bytes":807},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3CD8C31D78EBF47F","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/weaviate_collection.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f29b287e99d29dbd6d3008d1ad68e3960f9cc2c72459f04316f0311cd3e9a47d","size_bytes":18104},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E852EAB9373DF086","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"law_values/court_fee_values.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d1213e58b0de3b728945134e0a00a71565fee6db9077c932d7ee99da506c1115","size_bytes":912},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-309310FEC8A6178F","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"law_values/general_law_values.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"45ad98e9e93090fbc5e5c7037f404bd86ff89b73a4aaf8c3449d226bd2aacd1c","size_bytes":843},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-060B74A3C012D23C","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/authority_release.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967","size_bytes":1068},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B51F7A86E15908DD","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_coverage.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"34d6f758fc1486fa7330ede376e65b9448a6eaa971bd21472b0e4b7d9a5b8cba","size_bytes":143780},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-16A7CA30B83DD493","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6462217f08ced21693e8cfc812182cfc1da593d52e719e5cd11ef30409ffd00e","size_bytes":80525},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-34A6FBBE9101F1E8","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_rule_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ef42e873f497e1e2cfdf9440207f7caaa1f55462a3d47dc207b3c20f9c102793","size_bytes":56945},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3051DBC07D975B39","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/corpus_release.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"27d0c83e7a95342efdbe5be675b6d5b7d0ff8695eeec022ebc5aded3359fc981","size_bytes":920},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-98D409BCD1DE68FA","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/s2_20_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"19822af8fd0245c84b303955106c99ebdfcb5bbce06e76602178c90d4ecf6e82","size_bytes":5443},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-672D5EBD9C1F8AE0","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"migration/actio_assets_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0d1a3b5eaa7ea670f76db0baa8c30e23b4367904c3f715145737f1dff22f9204","size_bytes":10407},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2B7093A6A3B291AF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"migration/legacy_asset_disposition.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1b0c6b3bafd8bb11ec90e809d0fce057fec83fb12b1f9976471f8952ce073f2c","size_bytes":6039},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_authority_law_value_release.txt","mirror_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","mirror_size_bytes":7213,"module_id":"S2_20-ASSET-E3CE7EC9216DDBD3","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_authority_law_value_release.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","size_bytes":7213},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_corpus_snapshot.txt","mirror_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","mirror_size_bytes":9781,"module_id":"S2_20-ASSET-5F7DB1273D883DE5","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_corpus_snapshot.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","size_bytes":9781},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_release_manifests.txt","mirror_sha256":"9356d18267375e731e878ab301dcec01a728d73761df0dd65829599c00ccfcd5","mirror_size_bytes":30698,"module_id":"S2_20-ASSET-6CE2AD14244F5B49","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_release_manifests.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9356d18267375e731e878ab301dcec01a728d73761df0dd65829599c00ccfcd5","size_bytes":30698},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_20_inline_projection.txt","mirror_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","mirror_size_bytes":27865,"module_id":"S2_20-ASSET-86DCA2BCA2270252","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_s2_20_inline_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","size_bytes":27865},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/compile_case_type_registry.txt","mirror_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","mirror_size_bytes":9658,"module_id":"S2_20-ASSET-A360A270415B6E16","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/compile_case_type_registry.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","size_bytes":9658},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/compile_relief_rule_projection.txt","mirror_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","mirror_size_bytes":42682,"module_id":"S2_20-ASSET-B57CC23FD4D06275","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/compile_relief_rule_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","size_bytes":42682},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-DDC65130DFBDBA55","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/binding/binding_signature_projection.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b4317d0a5adc3f2bc70214c3e98c4f885ecfd26e36d8242221db4971b6f53142","size_bytes":835},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-AA1E72AB254FE6DC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-01_interest_delay.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d0d180a8f8af72d7dda5134b521122827fd2d1f9055c10d35ef5881d7d8cea53","size_bytes":1503},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-45939B38FC8F0B28","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-02_allocation_setoff_balance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"19a6a32b5879f20ed36df149cdbfb40ec2b5835152579e90a396f745e6299772","size_bytes":1511},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-A4DAC30C3F1AC365","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-03_limitation_deadline.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1dc66a75034576a41be43058ac421f5c8188288da9928df4d5b9cf616a819ea7","size_bytes":1515},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-D9EEBF8449D85E04","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-04_valuation.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e83044bfd16167cc6c1028afa06b0dc041e0114cee72379563047cff9fbeba11","size_bytes":1483},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BC815891D9220145","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-05_personal_injury.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0f197813d298f87010545d6eb09c4107c13303b6eb83d276e0130e25abaa7b00","size_bytes":1512},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2A85ED56A7C1242A","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-06_construction_defect.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1626c6673b7381e00fa61b7724ae63c8b10cb2ddd932040edc5f69889ffe5ab3","size_bytes":1522},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-6E799BF3C28471BC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-07_lease_use_gain.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f05c94ad80280607664a1ddcbd29367d0164333888c0d744dd674bf21cee3fad","size_bytes":1488},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3F219FD043EF4AE1","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-08_inheritance_reserved_share.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"330a1e5f72e4a4e4b7da096ceae554312ca2f828363b761ed37af37abf281818","size_bytes":1518},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BCAEF55DAB2126D1","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-09_wage_severance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"dba73da63069e89f95550419d989da78f8fe10196b052c49f050466a0dcda5b9","size_bytes":1489},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-81B84BD832C992EF","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-10_actio_insolvency_value.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c8710d3e9292b95e53d834006e784b13669b9023149e26628d0abaff074c1c85","size_bytes":1532},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2852DF1EC788C440","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-11_distribution_share_division.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4b3c8161ae779628575e122f1f602d6bee40b387c402c5ce642692796e1ab369","size_bytes":1512},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-FD4E3378C53FDCB5","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-12_insurance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"66d58d2043e45966df9db6c89e980f3c91cbdd6fcf4a4d96944fc203abedf532","size_bytes":1503},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-22371F1936240951","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-13_court_value_cost.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6f914553fd25a9ecb28d85070c2c0ddbf41178906f9075092f9d174977073824","size_bytes":1539},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-711DD22CD3721D81","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R1_ip_damage.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d33b7963d68cee10281da86e465caed152e3f69493728a563bca69c6dfb18c2b","size_bytes":1482},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B585B054934C1C1D","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R2_org_liquidation.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3bb03e07ba28a01d8c9e3944df55fbc43b21e17435bfa5e84ec60ef7b1540991","size_bytes":1513},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E032EAE75B122995","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R3_transport_maritime.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e64e808a4d1637c991f1ab512fad25f51637ecba3b2b0dfa66abb7efb8504c7e","size_bytes":1508},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-ED6526C35FE96ACC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R4_financial_instrument.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0198a5d09f9b75dd3b6978a01c9a8a3e468c8dd305c49721ae04ce93954b72d3","size_bytes":1510},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B0A8A8F08ECBF0AA","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/calculation_activation_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1a152af7e0ed4ee2ce10ab93bf3be343122f95e9f276585433449bde27c46e55","size_bytes":5540},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-69ADD915C1858F49","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/corpus/requirement_fact_scope.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6b38306dd4657df2c929caeb1b71bf78838f628e99018fff4692bacf4d49e2c1","size_bytes":216},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-A416DC6DB820828C","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/case_type_relief_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"01f95c0c1a95f80bfde1ee9c166ffb3ab1f22339ee035f5c322e2637329b8214","size_bytes":1416},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B8BE6EC64CED552C","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/counter_performance_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5c9e274f38fcfa4e8bfcb0938d2274b8dd83a6f8dac874de3c237b7a2608ab43","size_bytes":857},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5FDE95EE5314FCA7","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/forbidden_relief_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"fb51bec7b741e983a5e6f59f8265f3818c49f8067323e9b2090673a832eaae22","size_bytes":852},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8CDFE6C311F7F7D3","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/procedural_declaration_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3328d71a3fb020024fa8a0f8592788d409845d5ca0e2ca9a2b6c63ed3530147c","size_bytes":864},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-4414670A81E95DEA","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/party/party_set_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"92b1b8b76a396008629f534fdcd63995733ccdd71d6b2d9f9c4ad7360daf0c0a","size_bytes":225},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E1D9BDC792A7848D","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/planning/option_disposition_policy.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f3a656c3c1c0eabd22d26e4d3c9f541459af05727f595646a2f7a59d5c5e7658","size_bytes":426},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-CD373B0725950922","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/regression/finding_fixture_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"53c92c6b77c85d280aaa37ae5cc4fc355b3ee3e76c55bd87852bd25636f22992","size_bytes":8520},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-809C3C709B4F2295","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/review/review_policy_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"15b3181f7236f9500aea4699a95c71811761add2712eb4a5c4f8cbce11d4ef87","size_bytes":2301},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8EC84AB1A8C873B2","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/temporal/inheritance_reserved_share.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ca37eb894d04dcba604fe4656f941c44d76fafa1c221f4ffcdd988419a81d7a0","size_bytes":928},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"release_ops/canary_rollback.txt","mirror_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","mirror_size_bytes":1345,"module_id":"S2_20-ASSET-2040ED84718FA22C","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"release_ops/canary_rollback.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","size_bytes":1345},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"release_ops/release_validator.txt","mirror_sha256":"5c962c0ca084ce08a622764c874749bd837534b7b0a3af4ba9f879b975a0f866","mirror_size_bytes":55260,"module_id":"S2_20-ASSET-DBB6C2CCD4AB3FA2","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"release_ops/release_validator.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5c962c0ca084ce08a622764c874749bd837534b7b0a3af4ba9f879b975a0f866","size_bytes":55260},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-52C4FB90CB0F9E68","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R01_money_payment.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"98f06696a8c090078b2b4b72e8f25c6ecac342fbdafecfa4024d9f1bef7d6bbf","size_bytes":1844},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B031219CDF7A06DF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R02_delivery_possession.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"42d9654604aedd4dcbd6724b7960b0c42d281ec775c3a6c635941dd06abc564d","size_bytes":1781},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-7BEB573DD33365A1","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R03_declaration_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ff0e90951b373b662fafe70aa28fdff001b6c3a571180bb2d7537c23a0e4b641","size_bytes":1813},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-769585D81F81F620","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R04_special_nonmoney_performance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d1368fab9b91fadf3da0e864941708b7d82a39cda7110723f6a712489b9f014a","size_bytes":1875},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-04C3EF62029B522C","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R05_declaratory.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e903cd34bdf2e48479e5248a9ac120885dc612b27e34b5c9e2b6ce29c8cb89f5","size_bytes":1802},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BFC589A870A04F07","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R06_constitutive_judgment_challenge.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ada485d34b696a8d4e59d85d9e0d22a9f510448813ffa7985700b778581fcaaf","size_bytes":1840},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B2C88C2FFDE4487E","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"routing/actio_pauliana_mortgage_route.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"209fce4f610e7eb6c6ddc2995163de59537ca546752187c23dd1b417e2b117ec","size_bytes":721},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-DD9ABC431EB1B8BC","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"routing/actio_pauliana_route_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f30550aca6ce2a453bd39498d81653eb257cffcd6c693ba56b62f698a510427c","size_bytes":906},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/authority/authority_preflight.txt","mirror_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","mirror_size_bytes":2115,"module_id":"S2_20-ASSET-2317885DE36C87BB","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/authority/authority_preflight.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","size_bytes":2115},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/binding_signature_projection.txt","mirror_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","mirror_size_bytes":5843,"module_id":"S2_20-ASSET-2B67B561F6C4FD3B","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/binding_signature_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","size_bytes":5843},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c25_case_type_bind.txt","mirror_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","mirror_size_bytes":3471,"module_id":"S2_20-ASSET-2EABAE08AAE777EA","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c25_case_type_bind.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","size_bytes":3471},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c26_rule_branch_bind.txt","mirror_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","mirror_size_bytes":5089,"module_id":"S2_20-ASSET-FCA7B87C74F0BB44","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c26_rule_branch_bind.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","size_bytes":5089},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c27_query_plan.txt","mirror_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","mirror_size_bytes":6553,"module_id":"S2_20-ASSET-1327E50515C73062","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c27_query_plan.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","size_bytes":6553},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c28_weaviate_retrieve.txt","mirror_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","mirror_size_bytes":12083,"module_id":"S2_20-ASSET-4AE83266D12B501B","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c28_weaviate_retrieve.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","size_bytes":12083},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c29_pack_verify.txt","mirror_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","mirror_size_bytes":5721,"module_id":"S2_20-ASSET-0A121BEB45A15E4D","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c29_pack_verify.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","size_bytes":5721},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/calculators/registry_engine.txt","mirror_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","mirror_size_bytes":11417,"module_id":"S2_20-ASSET-FE154EB4E8F19440","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/calculators/registry_engine.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","size_bytes":11417},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E82839694073D431","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/binding_retrieval.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"25df409822a45fd26d0c5cf46e4afb55af100765c86afa148046354b2f02c8dc","size_bytes":47811},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-C9FC917D8CBF920E","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/calculation.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"7036793fe6c8d3550ca22486c281b1ffdbb915995dbe17c92d98a3f9a8f194ce","size_bytes":33698},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5D843BA99044953C","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/domain_verdict.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5fec56a0661e2ab2351d92939c4fbdedc8ac4c7e8699dc92caae7dd359c7eb16","size_bytes":1262},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-FF1F03B3FC56E579","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/relief_plan.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ef5d271e981390421fa7a188c01e52b390ab138bfc32203056f59d7ab6dfc8f2","size_bytes":31558},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-9A06594587743420","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/actio_route_cap_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f922b3ec10cc1da44c62d6ca5cf9c8ec5a53f5328b1eaabf236db46448907ca8","size_bytes":572},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3ECDA3121E0AE910","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/calculation_temporal_boundaries.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a31af03c418466b1dfc05f47ea05b58109fe142b813da2b3a8863e9d5f71004d","size_bytes":1612},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5EB4DEF644C02B9D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/case_type_rule_binding_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"45e0f7470e2907d20d6359d192fe8320051bf8a278f8eaa8153fbe964819685c","size_bytes":1042},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-60AF7FED54CBA5C1","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/case_type_zero_multi_hash_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0fbe5f68f4e60dfdd4fd03b9f6f076526f1b3d273b328ec853e69b4f9c315180","size_bytes":1123},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-49D464EEB3D65FFB","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/minimal_supported_portfolio.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4bcbcf19019e086e4eb4772cb55e87832c3a68c4829f67d50c6a7318dda79c86","size_bytes":733},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-97F26683DEAEA7F7","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/mixed_option_dispositions.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"509f3f436c8107c03033324413560b706487279bf91f2e231bd43bbc5c86b8e0","size_bytes":1457},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8A3BBD97738BC0BF","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/plan_publish_barrier_failure.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"29afbbdfa609234b06473542c35df7083ca6313155456cc6d1ec311fd50ea275","size_bytes":1640},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-47A96BFDC0754003","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"2a1a163d62a041990d71feaef54f3c56753ea3aa02666d3dc4c631552f7ee746","size_bytes":15014},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B42FA1C2AD23D1BA","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/retrieval_replay_injection.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8fbed161a30d52d8f5018f238dbf2cd01e0dd84162c97e3293df62d82a7ca804","size_bytes":1338},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_agent_and_inline_parity.txt","mirror_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","mirror_size_bytes":2773,"module_id":"S2_20-ASSET-E1B1709F62DB7D8A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_agent_and_inline_parity.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","size_bytes":2773},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_calculation_and_reports.txt","mirror_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","mirror_size_bytes":3199,"module_id":"S2_20-ASSET-1D1B579AA031EC90","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_calculation_and_reports.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","size_bytes":3199},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_inline_output_schema.txt","mirror_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","mirror_size_bytes":43574,"module_id":"S2_20-ASSET-22C24679226830D0","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_inline_output_schema.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","size_bytes":43574},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_offline_compilers.txt","mirror_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","mirror_size_bytes":20252,"module_id":"S2_20-ASSET-6FFF0ED2C88404C2","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_offline_compilers.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","size_bytes":20252},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_option_group_and_binding.txt","mirror_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","mirror_size_bytes":6171,"module_id":"S2_20-ASSET-E56589B5CCA0246C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_option_group_and_binding.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","size_bytes":6171},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_plan_publish_and_release.txt","mirror_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","mirror_size_bytes":13950,"module_id":"S2_20-ASSET-2868A4B922737A76","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_plan_publish_and_release.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","size_bytes":13950},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_regression_manifest_closure.txt","mirror_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","mirror_size_bytes":10028,"module_id":"S2_20-ASSET-0C03601E14F2D714","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_regression_manifest_closure.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","size_bytes":10028},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_retrieval_and_pack.txt","mirror_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","mirror_size_bytes":6654,"module_id":"S2_20-ASSET-A24AC597CB6DF548","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_retrieval_and_pack.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","size_bytes":6654},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-CAB87BA40B475A9D","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"validators/actio_value_compensation_invariants.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"591182a8869f3c0c0e03e9b32f5f0d9b856361b3f5f77f1e6e87eb0188f1ef22","size_bytes":983},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-AA40CF5140DE8790","module_kind":"WORKFLOW","outputs":[],"owner":"Stage_2_S2_20_owner","path":"workflows/S2_20_canonical_relief_plan_reduce.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"da56152af502fe432cb2ebaa593a4e389b7f2cd4d0b8f3be29e49717cff0544a","size_bytes":2443},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-871DF298A294D7DC","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"manifest/s2_30_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e4b734e354f4184dabe5984ed419f64636fc8a8daef12f6542ff960b2c7ab749","size_bytes":1603},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_30_agent_projection.txt","mirror_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","mirror_size_bytes":56585,"module_id":"S2_30-ASSET-66EF7EC35105D464","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_30_owner","path":"offline_build/build_s2_30_agent_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/validate_s2_30_contract.txt","mirror_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","mirror_size_bytes":104292,"module_id":"S2_30-ASSET-7E89202630AA3B4A","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_30_owner","path":"offline_build/validate_s2_30_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E83A5821C44AAF21","module_kind":"S2_30_ASSET","outputs":[],"owner":"Stage_2_S2_30_owner","path":"prompts/P30_joint_drafting_contract.md","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-6A9B1F5EC854740E","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_30_owner","path":"schemas/draft_atoms.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5107b64f01ffb3633a829c10652747760a5035c9cc07227c546e3f543005eda9","size_bytes":68470},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-546763E72E7A932F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/adverse_fact_worknote_policy.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5b8e9101385f8d65b0332c3be63cb9a22063920675cc86aee51e04da7820aef7","size_bytes":3444},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-47ECD04400C72037","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/cache_prefix_drift.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"845b44cfeb1246f16cd3458965683247efc360b166b31133e3286be400325f98","size_bytes":2109},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-9C7A8A9DC09BB101","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/context_reference_envelope.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a1d6ba9752b9d4fb479dfaaa763174988f38d87890db9487db9de556d3eade60","size_bytes":4804},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-0DA94639658F5DB2","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/counter_performance_and_declaration.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cfa3a8439ca938b05768798dfee39a3cc1e4980d5550526c787843622516da90","size_bytes":3322},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-CA60AEE03DF32752","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/follower_batch_dispatch.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3dffaf9862e15f2fe906ca63abb3be61e49177fb58abb4c4a7a8b25db4e4493b","size_bytes":2832},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-18231E85556C3220","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_forbidden_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a2308629fc09f75ab226b89374c78323f62a9dbe296aebdd83170a0cfb926e09","size_bytes":2741},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-8265AF415D892AB3","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_preassembled_prompt_item.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6655402c669e5b40f2e7028a5c0c89571d8e1597dbdef567b4c9d8e2eed15a79","size_bytes":2204},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-A7A8934E5BF55C76","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_reference_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"eb2982a09f4948baadc27ae49c4f125426074333ea4a626e9c56ddc5c24ce273","size_bytes":2663},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-D8A8B0F06569C1F0","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/owner_singleton_dispatch.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"38f9c364591fcdfe60d0dea9f69eb86b2f3b883929f6d60d06a7c35ff376fca6","size_bytes":8448},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-7D7984D0B44475DA","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/partial_write_publish_barrier.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0d878b946ebf810e8d0d8da74af33e56f35e164b04076a3867344b95d5f953eb","size_bytes":3352},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-B1A866CA34AFBC11","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"43e5b20ef4389da9c03b8062ce8bfacf2cd880d2efa2a1cbe1e901f4111f64ea","size_bytes":3584},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E696214E5807E29A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/rule_requirement_admission_gap.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"27dfad63f3508c5d40521270707d84b2bc0c58f035f47d0cde1ae2abc54f9a15","size_bytes":4298},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-C8F5D82811189C0F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/technical_failure.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"bdcc6410e7515edc73d6b154d5b618b3ec34273ddc7269dc3e3ce55a6eb35fa6","size_bytes":2719},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-77E545820FEC15EC","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/valid_joint_draft_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0135616c9375602693af8e12c3c16cf2031eaf3d9b74783bec9b5065846327e8","size_bytes":12982},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_agent_contract.txt","mirror_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","mirror_size_bytes":12199,"module_id":"S2_30-ASSET-97349E7C166EE517","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_agent_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_dispatch_materialization.txt","mirror_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","mirror_size_bytes":13911,"module_id":"S2_30-ASSET-748AB3E90AD4378F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_dispatch_materialization.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_draft_atom_contract.txt","mirror_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","mirror_size_bytes":10484,"module_id":"S2_30-ASSET-5165C83A0FB3CDEE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_draft_atom_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","mirror_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","mirror_size_bytes":6284,"module_id":"S2_30-ASSET-30A7574DB26A7700","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_prompt_cache_and_boundaries.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_release_adapter_retry.txt","mirror_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","mirror_size_bytes":18566,"module_id":"S2_30-ASSET-A9BE2C9D380E8C50","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_release_adapter_retry.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E1FCF8BD63300F4D","module_kind":"WORKFLOW","outputs":[],"owner":"Stage_2_S2_30_owner","path":"workflows/S2_30_claim_group_draft_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b266e7b7ae8939b087bfdb7b34fff8b9c6011c835560ab690991d856ced0cc15","size_bytes":15221},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-710AE87909AE0663","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"manifest/s2_40_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3ab6c0398f16d53542c115f2efa164f5ccfd1e64bf457b914a589c61321e8121","size_bytes":2257},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_40_inline_projection.txt","mirror_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","mirror_size_bytes":36098,"module_id":"S2_40-ASSET-1CF70696C9F630A8","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_40_owner","path":"offline_build/build_s2_40_inline_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","size_bytes":36098},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c45_document_assembler.txt","mirror_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","mirror_size_bytes":11992,"module_id":"S2_40-ASSET-5B0EE99ECD2C0599","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/c45_document_assembler.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","size_bytes":11992},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/rendering/closed_renderer.txt","mirror_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","mirror_size_bytes":10559,"module_id":"S2_40-ASSET-0B59F323E4EACA18","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/rendering/closed_renderer.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","size_bytes":10559},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/validation/invariant_runner.txt","mirror_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","mirror_size_bytes":30951,"module_id":"S2_40-ASSET-8217116B75E9550A","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/validation/invariant_runner.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","size_bytes":30951},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-66B24FF9775426E0","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_40_owner","path":"schemas/migration_regression.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"775a186df990e3704391876926540da911d64c56f76b0bee6c0b97c6cdb38e58","size_bytes":4610},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-5C4CAFFAB8D2F982","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_40_owner","path":"schemas/package.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c1cdf59d7273715276e38fe227c5dad5d7b825cc522118ff6ab2d1b3a342dd3c","size_bytes":19691},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-F261637CB908A41C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/persisted_handoff_chain.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"54d6d781a60640744cba4b9c2f88a0013a6e58656c9c80a809e39fd4ba7c1097","size_bytes":2016},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-19CB23FB1E5F99DE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/candidate_digest_noncycle.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"74885602909bd19ca1678de781cac26afd34c2f386e98fc0370fd6ff6fb7b8bf","size_bytes":798},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-9E10C878E97D6636","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/cost_provisional_execution_numbering.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"17c380492f5bc56ecf675cf9683784b2e463241c7d0589b7b496e7a381145c9b","size_bytes":2143},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-D73DC5121366E2DE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/exhibit_object_party_title_completeness.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"40045822f45b2a57805504744e751ee420a6187d0790d5a0f442f529ffedcf7e","size_bytes":692},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-71BEFE2BDE251773","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/part_set_missing_duplicate_or_cross_group.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"379273497ee23d4a515135771ba4d3bb5ff0e38325ad40eb4e0a0008cd6b88f4","size_bytes":785},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-C245AA392434948E","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/partial_write_readback_barrier.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"467387c12a4cc6469d243de9f0a7948276adb558a99b3b661ccd74a5d17629cf","size_bytes":652},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-B77178D146E18FE6","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ac5d68c8d4061d789aa5c773cd1ffb37728c33c7725785a9dd1f4bea63ec88ce","size_bytes":7030},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-724CEBB85D0021D4","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/relief_cause_crossmatch_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e8d148fef61920039e36abd0cfb771cc6e2fe3aa1a9cc0b0b0502c38ddf70567","size_bytes":761},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-D8B6C423CA8B8343","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/renderer_ast_slot_branch_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e70ecac4e71de962dfe8bb025a42c73c7c03cfba32c29319523d19f49e8260d0","size_bytes":1800},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-ED81C6D9C14D5A6A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_policy_state_aggregation.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"953fc301703ff353de4df3cf46ed4e90b6bf4ce8268b08705e16151ffc8c3a21","size_bytes":581},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-88DA222DF4B4AC40","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_approve_resume.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c5b84e34358761750e8e9e7666de6532e0f22a31f32bf027f24efb256a1af5d5","size_bytes":983},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-45C755C76F2E9040","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_content_change_supersede.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"400d4aeb455e5c3ec26c75a552ea91e9af79cb2329998caa1ad72d1be18da8e7","size_bytes":627},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-60A3C7B6370B71D7","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_missing_or_invalid.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a88645be90a9e0943358d83f7ea105193dd4b4dfebea4519702a17f69615dc65","size_bytes":688},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-010B031F043CFB13","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/same_binding_idempotence_and_commit_conflict.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5536793236fa44da601dc8cf65d94dac32b18ebc2e8dc525a6df92106add57ad","size_bytes":674},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-1FD9A637BC46671D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/v01_v18_invariant_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e4c0a5476647fa1860cd685a15aad6d465a36b4f6b648c8e2a066c8747780eb8","size_bytes":9096},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-CDB97542A2A4F866","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/valid_full_candidate_and_commit.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e98e8dc55ab60f8f875ad2f58c1aec35eb1da3882371c22c3e232e0e9ae46c2f","size_bytes":1221},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-01E38009C9220C87","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/valid_status_only_diagnostic.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5676088f5d79168cbae5e1481da4b7cfd9241d06c935378e06dd2af56aae6285","size_bytes":724},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_agent_and_inline_parity.txt","mirror_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","mirror_size_bytes":32947,"module_id":"S2_40-ASSET-A6B20D5A9A6882F5","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_agent_and_inline_parity.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","size_bytes":32947},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_c40_reduce_and_conservation.txt","mirror_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","mirror_size_bytes":3032,"module_id":"S2_40-ASSET-46C37B9570DE79C8","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_c40_reduce_and_conservation.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","size_bytes":3032},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_c45_closed_render.txt","mirror_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","mirror_size_bytes":7855,"module_id":"S2_40-ASSET-A2E1E4DAA289FE95","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_c45_closed_render.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","size_bytes":7855},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_commit_barrier_and_idempotence.txt","mirror_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","mirror_size_bytes":8228,"module_id":"S2_40-ASSET-6CFF5B81DB1AE376","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_commit_barrier_and_idempotence.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","size_bytes":8228},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_release_closure.txt","mirror_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","mirror_size_bytes":12692,"module_id":"S2_40-ASSET-3309DF833726005D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_release_closure.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","size_bytes":12692},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_review_state_machine.txt","mirror_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","mirror_size_bytes":8373,"module_id":"S2_40-ASSET-EDD6AFC9610DFC1B","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_review_state_machine.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","size_bytes":8373},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_v01_v18.txt","mirror_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","mirror_size_bytes":3853,"module_id":"S2_40-ASSET-A50D95FF51F9CA3C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_v01_v18.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","size_bytes":3853}],"producer_aliases":[{"alias_id":"PA-SG-COMPILER-001","bidirectional_match_allowed":true,"contract_status":"CLOSED_DECISION_FIXTURE_PENDING","global_alias_allowed":false,"orchestration_producer_id":"Task_C_BO_S0_signal_bundle_writer","schema_writer_id":"Task_C_BO_S0_canonical_signal_compiler","scope":"STAGE1_PART2_SIGNAL_TRANSACTION_ONLY"}],"schema_version":"stage2_module_manifest.v1"} +{"closure_summary":{"build_tool_module_count":1,"cycle_breaking_contract":"AGENT_CODE_RECEIPT_AND_EXECUTOR_BINDING_EXTERNALLY_BIND_RELEASE_RAW_HASH","documentation_mirror_count":58,"executable_agent_hash_included":false,"executor_binding_hash_included":false,"fixture_closure_ref":"tests/fixtures/regression_manifest.json","fixture_descriptor_count":60,"generic_module_counts_by_stage":{"S2_20":90,"S2_30":26,"S2_40":30},"inline_runtime_code_hash_included":false,"module_count":223,"profile_module_count":45,"prompt_module_count":2,"runtime_code_hash_included":false,"s2_20_generic_module_count":90,"s2_30_generic_module_count":26,"s2_40_generic_module_count":30,"self_hash_included":false,"stage2_release_hash_included":false,"test_module_count":73},"documentation_mirrors":[{"byte_identical":true,"mirror_path":"offline_build/build_authority_law_value_release.txt","mirror_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","mirror_size_bytes":7213,"runtime_import_allowed":false,"source_path":"offline_build/build_authority_law_value_release.py","source_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","source_size_bytes":7213},{"byte_identical":true,"mirror_path":"offline_build/build_corpus_snapshot.txt","mirror_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","mirror_size_bytes":9781,"runtime_import_allowed":false,"source_path":"offline_build/build_corpus_snapshot.py","source_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","source_size_bytes":9781},{"byte_identical":true,"mirror_path":"offline_build/build_release_manifests.txt","mirror_sha256":"149e419021b7faf9e7d8d7799f5ce3c75b209ce6155ec503dd2d2197ee45bc7b","mirror_size_bytes":30787,"runtime_import_allowed":false,"source_path":"offline_build/build_release_manifests.py","source_sha256":"149e419021b7faf9e7d8d7799f5ce3c75b209ce6155ec503dd2d2197ee45bc7b","source_size_bytes":30787},{"byte_identical":true,"mirror_path":"offline_build/build_s2_00_inline_projection.txt","mirror_sha256":"e28619d262d2870e93ae94bdd3b5cafd357a1c9047f3115811e1e0de62894676","mirror_size_bytes":39188,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_00_inline_projection.py","source_sha256":"e28619d262d2870e93ae94bdd3b5cafd357a1c9047f3115811e1e0de62894676","source_size_bytes":39188},{"byte_identical":true,"mirror_path":"offline_build/build_s2_10_agent_projection.txt","mirror_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","mirror_size_bytes":68381,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_10_agent_projection.py","source_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","source_size_bytes":68381},{"byte_identical":true,"mirror_path":"offline_build/build_s2_20_inline_projection.txt","mirror_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","mirror_size_bytes":27865,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_20_inline_projection.py","source_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","source_size_bytes":27865},{"byte_identical":true,"mirror_path":"offline_build/build_s2_30_agent_projection.txt","mirror_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","mirror_size_bytes":56585,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_30_agent_projection.py","source_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","source_size_bytes":56585},{"byte_identical":true,"mirror_path":"offline_build/build_s2_40_inline_projection.txt","mirror_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","mirror_size_bytes":36098,"runtime_import_allowed":false,"source_path":"offline_build/build_s2_40_inline_projection.py","source_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","source_size_bytes":36098},{"byte_identical":true,"mirror_path":"offline_build/compile_case_type_registry.txt","mirror_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","mirror_size_bytes":9658,"runtime_import_allowed":false,"source_path":"offline_build/compile_case_type_registry.py","source_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","source_size_bytes":9658},{"byte_identical":true,"mirror_path":"offline_build/compile_relief_rule_projection.txt","mirror_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","mirror_size_bytes":42682,"runtime_import_allowed":false,"source_path":"offline_build/compile_relief_rule_projection.py","source_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","source_size_bytes":42682},{"byte_identical":true,"mirror_path":"offline_build/validate_s2_10_contract.txt","mirror_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","mirror_size_bytes":63811,"runtime_import_allowed":false,"source_path":"offline_build/validate_s2_10_contract.py","source_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","source_size_bytes":63811},{"byte_identical":true,"mirror_path":"offline_build/validate_s2_30_contract.txt","mirror_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","mirror_size_bytes":104292,"runtime_import_allowed":false,"source_path":"offline_build/validate_s2_30_contract.py","source_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","source_size_bytes":104292},{"byte_identical":true,"mirror_path":"release_ops/canary_rollback.txt","mirror_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","mirror_size_bytes":1345,"runtime_import_allowed":false,"source_path":"release_ops/canary_rollback.py","source_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","source_size_bytes":1345},{"byte_identical":true,"mirror_path":"release_ops/release_validator.txt","mirror_sha256":"fa6777fb28554498df57666d393a380ff0a00d52a11bc3e7166010547e4d391d","mirror_size_bytes":55349,"runtime_import_allowed":false,"source_path":"release_ops/release_validator.py","source_sha256":"fa6777fb28554498df57666d393a380ff0a00d52a11bc3e7166010547e4d391d","source_size_bytes":55349},{"byte_identical":true,"mirror_path":"runtime/authority/authority_preflight.txt","mirror_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","mirror_size_bytes":2115,"runtime_import_allowed":false,"source_path":"runtime/authority/authority_preflight.py","source_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","source_size_bytes":2115},{"byte_identical":true,"mirror_path":"runtime/binding_signature_projection.txt","mirror_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","mirror_size_bytes":5843,"runtime_import_allowed":false,"source_path":"runtime/binding_signature_projection.py","source_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","source_size_bytes":5843},{"byte_identical":true,"mirror_path":"runtime/c25_case_type_bind.txt","mirror_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","mirror_size_bytes":3471,"runtime_import_allowed":false,"source_path":"runtime/c25_case_type_bind.py","source_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","source_size_bytes":3471},{"byte_identical":true,"mirror_path":"runtime/c26_rule_branch_bind.txt","mirror_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","mirror_size_bytes":5089,"runtime_import_allowed":false,"source_path":"runtime/c26_rule_branch_bind.py","source_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","source_size_bytes":5089},{"byte_identical":true,"mirror_path":"runtime/c27_query_plan.txt","mirror_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","mirror_size_bytes":6553,"runtime_import_allowed":false,"source_path":"runtime/c27_query_plan.py","source_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","source_size_bytes":6553},{"byte_identical":true,"mirror_path":"runtime/c28_weaviate_retrieve.txt","mirror_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","mirror_size_bytes":12083,"runtime_import_allowed":false,"source_path":"runtime/c28_weaviate_retrieve.py","source_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","source_size_bytes":12083},{"byte_identical":true,"mirror_path":"runtime/c29_pack_verify.txt","mirror_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","mirror_size_bytes":5721,"runtime_import_allowed":false,"source_path":"runtime/c29_pack_verify.py","source_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","source_size_bytes":5721},{"byte_identical":true,"mirror_path":"runtime/c45_document_assembler.txt","mirror_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","mirror_size_bytes":11992,"runtime_import_allowed":false,"source_path":"runtime/c45_document_assembler.py","source_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","source_size_bytes":11992},{"byte_identical":true,"mirror_path":"runtime/calculators/registry_engine.txt","mirror_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","mirror_size_bytes":11417,"runtime_import_allowed":false,"source_path":"runtime/calculators/registry_engine.py","source_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","source_size_bytes":11417},{"byte_identical":true,"mirror_path":"runtime/rendering/closed_renderer.txt","mirror_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","mirror_size_bytes":10559,"runtime_import_allowed":false,"source_path":"runtime/rendering/closed_renderer.py","source_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","source_size_bytes":10559},{"byte_identical":true,"mirror_path":"runtime/validation/invariant_runner.txt","mirror_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","mirror_size_bytes":30951,"runtime_import_allowed":false,"source_path":"runtime/validation/invariant_runner.py","source_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","source_size_bytes":30951},{"byte_identical":true,"mirror_path":"tests/s2_00/test_canonical_ids.txt","mirror_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","mirror_size_bytes":2275,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_canonical_ids.py","source_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","source_size_bytes":2275},{"byte_identical":true,"mirror_path":"tests/s2_00/test_cluster_bundle_compile.txt","mirror_sha256":"1b7a58ae53e7465cd39f0c911c4fab8e96b9e89df707eb9423e8a22fabc0a54b","mirror_size_bytes":25874,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_cluster_bundle_compile.py","source_sha256":"1b7a58ae53e7465cd39f0c911c4fab8e96b9e89df707eb9423e8a22fabc0a54b","source_size_bytes":25874},{"byte_identical":true,"mirror_path":"tests/s2_00/test_conservation.txt","mirror_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","mirror_size_bytes":5562,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_conservation.py","source_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","source_size_bytes":5562},{"byte_identical":true,"mirror_path":"tests/s2_00/test_failure_and_atomic_publish.txt","mirror_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","mirror_size_bytes":25937,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_failure_and_atomic_publish.py","source_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","source_size_bytes":25937},{"byte_identical":true,"mirror_path":"tests/s2_00/test_inline_code_parity.txt","mirror_sha256":"325e0ed4dc7a4562b87946f2ff68693865997bd33b55ce5d0a6c558920404a18","mirror_size_bytes":17586,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_inline_code_parity.py","source_sha256":"325e0ed4dc7a4562b87946f2ff68693865997bd33b55ce5d0a6c558920404a18","source_size_bytes":17586},{"byte_identical":true,"mirror_path":"tests/s2_00/test_prepare_request.txt","mirror_sha256":"db76d064f742c2003eacfcb4814ba0b9d0b36984622147485cbab1139d5deaeb","mirror_size_bytes":6946,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_prepare_request.py","source_sha256":"db76d064f742c2003eacfcb4814ba0b9d0b36984622147485cbab1139d5deaeb","source_size_bytes":6946},{"byte_identical":true,"mirror_path":"tests/s2_00/test_resolver_source_lock.txt","mirror_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","mirror_size_bytes":14423,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_resolver_source_lock.py","source_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","source_size_bytes":14423},{"byte_identical":true,"mirror_path":"tests/s2_00/test_schema_hash_and_signals.txt","mirror_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","mirror_size_bytes":12842,"runtime_import_allowed":false,"source_path":"tests/s2_00/test_schema_hash_and_signals.py","source_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","source_size_bytes":12842},{"byte_identical":true,"mirror_path":"tests/s2_10/test_agent_contract.txt","mirror_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","mirror_size_bytes":8076,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_agent_contract.py","source_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","source_size_bytes":8076},{"byte_identical":true,"mirror_path":"tests/s2_10/test_domain_verdict_contract.txt","mirror_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","mirror_size_bytes":10242,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_domain_verdict_contract.py","source_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","source_size_bytes":10242},{"byte_identical":true,"mirror_path":"tests/s2_10/test_prompt_cache_and_boundaries.txt","mirror_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","mirror_size_bytes":11365,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_prompt_cache_and_boundaries.py","source_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","source_size_bytes":11365},{"byte_identical":true,"mirror_path":"tests/s2_10/test_release_adapter_retry.txt","mirror_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","mirror_size_bytes":10848,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_release_adapter_retry.py","source_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","source_size_bytes":10848},{"byte_identical":true,"mirror_path":"tests/s2_10/test_wave_dispatch.txt","mirror_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","mirror_size_bytes":9894,"runtime_import_allowed":false,"source_path":"tests/s2_10/test_wave_dispatch.py","source_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","source_size_bytes":9894},{"byte_identical":true,"mirror_path":"tests/s2_20/test_agent_and_inline_parity.txt","mirror_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","mirror_size_bytes":2773,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_agent_and_inline_parity.py","source_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","source_size_bytes":2773},{"byte_identical":true,"mirror_path":"tests/s2_20/test_calculation_and_reports.txt","mirror_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","mirror_size_bytes":3199,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_calculation_and_reports.py","source_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","source_size_bytes":3199},{"byte_identical":true,"mirror_path":"tests/s2_20/test_inline_output_schema.txt","mirror_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","mirror_size_bytes":43574,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_inline_output_schema.py","source_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","source_size_bytes":43574},{"byte_identical":true,"mirror_path":"tests/s2_20/test_offline_compilers.txt","mirror_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","mirror_size_bytes":20252,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_offline_compilers.py","source_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","source_size_bytes":20252},{"byte_identical":true,"mirror_path":"tests/s2_20/test_option_group_and_binding.txt","mirror_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","mirror_size_bytes":6171,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_option_group_and_binding.py","source_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","source_size_bytes":6171},{"byte_identical":true,"mirror_path":"tests/s2_20/test_plan_publish_and_release.txt","mirror_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","mirror_size_bytes":13950,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_plan_publish_and_release.py","source_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","source_size_bytes":13950},{"byte_identical":true,"mirror_path":"tests/s2_20/test_regression_manifest_closure.txt","mirror_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","mirror_size_bytes":10028,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_regression_manifest_closure.py","source_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","source_size_bytes":10028},{"byte_identical":true,"mirror_path":"tests/s2_20/test_retrieval_and_pack.txt","mirror_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","mirror_size_bytes":6654,"runtime_import_allowed":false,"source_path":"tests/s2_20/test_retrieval_and_pack.py","source_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","source_size_bytes":6654},{"byte_identical":true,"mirror_path":"tests/s2_30/test_agent_contract.txt","mirror_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","mirror_size_bytes":12199,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_agent_contract.py","source_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","source_size_bytes":12199},{"byte_identical":true,"mirror_path":"tests/s2_30/test_dispatch_materialization.txt","mirror_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","mirror_size_bytes":13911,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_dispatch_materialization.py","source_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","source_size_bytes":13911},{"byte_identical":true,"mirror_path":"tests/s2_30/test_draft_atom_contract.txt","mirror_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","mirror_size_bytes":10484,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_draft_atom_contract.py","source_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","source_size_bytes":10484},{"byte_identical":true,"mirror_path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","mirror_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","mirror_size_bytes":6284,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_prompt_cache_and_boundaries.py","source_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","source_size_bytes":6284},{"byte_identical":true,"mirror_path":"tests/s2_30/test_release_adapter_retry.txt","mirror_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","mirror_size_bytes":18566,"runtime_import_allowed":false,"source_path":"tests/s2_30/test_release_adapter_retry.py","source_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","source_size_bytes":18566},{"byte_identical":true,"mirror_path":"tests/s2_40/test_agent_and_inline_parity.txt","mirror_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","mirror_size_bytes":32947,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_agent_and_inline_parity.py","source_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","source_size_bytes":32947},{"byte_identical":true,"mirror_path":"tests/s2_40/test_c40_reduce_and_conservation.txt","mirror_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","mirror_size_bytes":3032,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_c40_reduce_and_conservation.py","source_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","source_size_bytes":3032},{"byte_identical":true,"mirror_path":"tests/s2_40/test_c45_closed_render.txt","mirror_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","mirror_size_bytes":7855,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_c45_closed_render.py","source_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","source_size_bytes":7855},{"byte_identical":true,"mirror_path":"tests/s2_40/test_commit_barrier_and_idempotence.txt","mirror_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","mirror_size_bytes":8228,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_commit_barrier_and_idempotence.py","source_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","source_size_bytes":8228},{"byte_identical":true,"mirror_path":"tests/s2_40/test_release_closure.txt","mirror_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","mirror_size_bytes":12692,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_release_closure.py","source_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","source_size_bytes":12692},{"byte_identical":true,"mirror_path":"tests/s2_40/test_review_state_machine.txt","mirror_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","mirror_size_bytes":8373,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_review_state_machine.py","source_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","source_size_bytes":8373},{"byte_identical":true,"mirror_path":"tests/s2_40/test_v01_v18.txt","mirror_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","mirror_size_bytes":3853,"runtime_import_allowed":false,"source_path":"tests/s2_40/test_v01_v18.py","source_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","source_size_bytes":3853}],"forbidden_contract_registry":[{"code":"LEGACY-STAGE2-V0-V3","legacy_runtime_dependency_allowed":false,"meaning":"The clean S2_00 workflow and runtime must not read or execute legacy Stage 2 v.0-v.3 specifications."},{"code":"LEGACY-STAGE2-LOADER","legacy_runtime_dependency_allowed":false,"meaning":"The historical host loader and loader binding are reference-only and cannot authorize, execute, or provide fallback for S2_00."},{"code":"RAW-STAGE1-REREAD","legacy_runtime_dependency_allowed":false,"meaning":"S2_10 must consume immutable bounded cluster projections and must not rediscover raw Stage 1 inputs."},{"code":"S2_40-PLEADING-RENDER-IN-STATUS-ONLY","legacy_runtime_dependency_allowed":false,"meaning":"The S2_40 status-only entrypoint must not render or commit pleading text."}],"implementation_status":"OFFLINE_HYBRID_RESEAL_COMPLETE_LIVE_ADMISSION_PENDING","manifest_digest":"cd5460b3a46865c7d0bc59595a99627e135602f974432ecd30e6850d4f25a604","manifest_digest_contract":{"algorithm_id":"STAGE2-MODULE-MANIFEST-DIGEST-V1","array_order":"PRESERVE_DECLARED_ORDER","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","digest_algorithm":"sha256","digest_scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_MANIFEST_DIGEST","encoding":"UTF-8","line_termination":"LF_ONE_TRAILING_NEWLINE","non_finite_numbers_allowed":false,"object_key_order":"SORT_CODEPOINT","verification_status":"DEV_VERIFIED"},"manifest_id":"STAGE2-CLEAN-S2_00-STRUCTURED-HANDOFF-V2-INLINE","manifest_scope":"S2_00_STRUCTURED_CONTEXT_HANDOFF_AND_SHARED_CONTRACTS","manifest_status":"DEV_HASH_BOUND_DOWNSTREAM_HYBRID_RELEASE_PENDING","modules":[{"asset_version":"s2_00.1.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json","https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-INGRESS","SCHEMA-CONTEXT","SCHEMA-REVIEW-STATUS"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"IMPLEMENTED_DECLARATIVE_CONTRACT","incompatible_module_ids":[],"inputs":["STAGE1-ALLOWLIST-V1","STAGE1-DEPLOYMENT-CLOSURE-2026-08-29"],"module_id":"WF-S2_00","module_kind":"WORKFLOW","outputs":["S2_00-NORMAL-BRANCH","S2_00-DIAGNOSTIC-BRANCH"],"owner":"Stage_2_workflow_maintainer","path":"workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml","produced_schema_ids":[],"schema_version":"stage2_workflow_contract.v1.2","scope_predicate":"workflow_id == S2_00","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"9b606ef4ddc7859591d9455fd9cdf9dfe6ad2533824636deb727b82e035f503a","size_bytes":18011},{"asset_version":"s2_00.schema.1.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-INGRESS","module_kind":"JSON_SCHEMA","outputs":["INGRESS-SCHEMA-DEFS"],"owner":"Stage_2_schema_owner","path":"schemas/ingress.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json"],"schema_version":"stage2_s2_00_ingress.v1.1","scope_predicate":"artifact_family == ingress","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"8fd7b76015b7d7dfbbe056e08999dda7ea8e1012bb16cec50634b08f7ea97302","size_bytes":33444},{"asset_version":"s2_00.schema.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-REVIEW-STATUS"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-CONTEXT","module_kind":"JSON_SCHEMA","outputs":["CONTEXT-SCHEMA-DEFS"],"owner":"Stage_2_schema_owner","path":"schemas/context.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json"],"schema_version":"stage2_s2_00_context.v2","scope_predicate":"artifact_family == context","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"29073ffa847d74304228d61306503c0c3798da7db8b5717b1ad6d5b2da98aa92","size_bytes":39054},{"asset_version":"stage2.shared.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-DEPLOYMENT","module_kind":"JSON_SCHEMA","outputs":["DEPLOYMENT-SCHEMA-DEFS"],"owner":"Stage_2_deployment_schema_owner","path":"schemas/deployment.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"schema_version":"stage2_deployment.v2","scope_predicate":"artifact_family == deployment","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"693ed28c290c7dfa7ed97df08c216d399abc601ee768844719fd2a07e6da155c","size_bytes":96687},{"asset_version":"stage2.shared.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"SCHEMA-REVIEW-STATUS","module_kind":"JSON_SCHEMA","outputs":["REVIEW-STATUS-SCHEMA-DEFS"],"owner":"Stage_2_review_schema_owner","path":"schemas/review_status.schema.json","produced_schema_ids":["https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"schema_version":"stage2_review_status.v1","scope_predicate":"artifact_family == review_status","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"dbf559cae183b9e9878a56ff9364ddfe68f7bf6ba1e00e595ec8876f2fc01d95","size_bytes":27241},{"asset_version":"stage2.cache.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-CONTEXT"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["RELEASE-SELECTED-CONTEXT-ORDERED-REFS","S2_00-COHORT-MEMBERSHIP","S2_00-MEMBER-SLICE-REF-SET"],"module_id":"CACHE-POLICY-STRUCTURED-CONTEXT-HANDOFF","module_kind":"CACHE_POLICY","outputs":["S2_00-CONTEXT-MATERIALIZATION-RECEIPT","S2_10-CACHE-IDENTITY-INPUT"],"owner":"Stage_2_cache_policy_owner","path":"registry/cache/prompt_cache_policy.yml","produced_schema_ids":[],"schema_version":"stage2_prompt_cache_policy.v2","scope_predicate":"consumer == S2_10","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"32b638073b721a9f395d3476105e57236be4e076be81fd6e93f1475b29b93e2a","size_bytes":7527},{"asset_version":"s2_00.test.1.2","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"module_id":"REGRESSION-MANIFEST-S2_00","module_kind":"TEST_MANIFEST","outputs":["FIXTURE-RESULT-DIGEST"],"owner":"Stage_2_regression_owner","path":"tests/fixtures/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_00_regression_manifest.v1","scope_predicate":"workflow_id == S2_00","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"98c9f150c7458024a44e0a482ec701522e701675a203be0b7c4325b2d83d297d","size_bytes":58202},{"asset_version":"s2_40.finalizer.1","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/s2_00/context.schema.v2.json","https://schemas.liti-agent.local/stage2/s2_00/ingress.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_10/s2_10.schema.v2.json","https://schemas.liti-agent.local/stage2/s2_20/binding_retrieval.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_20/calculation.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_20/relief_plan.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_30/draft_atoms.schema.v1.json","https://schemas.liti-agent.local/stage2/s2_40/package.schema.v1.json","https://schemas.liti-agent.local/stage2/shared/deployment.schema.v3.json","https://schemas.liti-agent.local/stage2/shared/review_status.schema.v1.json"],"dependency_module_ids":["SCHEMA-CONTEXT","SCHEMA-DEPLOYMENT","SCHEMA-INGRESS","SCHEMA-REVIEW-STATUS","SCHEMA-S2_10","S2_20-ASSET-809C3C709B4F2295","S2_20-ASSET-AA40CF5140DE8790","S2_20-ASSET-C9FC917D8CBF920E","S2_20-ASSET-E82839694073D431","S2_20-ASSET-FF1F03B3FC56E579","S2_30-ASSET-6A9B1F5EC854740E","S2_30-ASSET-E1FCF8BD63300F4D","S2_40-ASSET-5C4CAFFAB8D2F982","WF-S2_00","WF-S2_10"],"entry_routes":["TO_S2_40","TO_S2_40_STATUS_ONLY"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","S2_40-DIRECTORY-SCAN","S2_40-FREE-TEXT-RENDER-FALLBACK","S2_40-LLM-CALL","S2_40-RUN-STATUS-NOT-LAST","S2_40-UNVERIFIED-READY"],"implementation_status":"IMPLEMENTED_OFFLINE_CONTRACT_LIVE_ADMISSION_PENDING","incompatible_module_ids":[],"inputs":["ingress/ingress_status.json","ingress/technical_diagnostic.json","ingress/stage1_input_manifest.json","ingress/intake_report.json","review/issue_ledger.base.json","map_s2_10/s2_10_publish_status.json","plan/plan_publish_status.json","plan/canonical_relief_plan.json","plan/claim_groups.json","plan/case_type_bindings.json","map_s2_30/s2_30_publish_status.json","map_s2_30/artifact_manifest.json","map_s2_30/{draft_parts,issue_patches,worknote_parts,usage_parts}/.json","review/review_receipts/.json","review/lawyer_judgment_record.json"],"legal_admission_status":"PENDING","live_admission_status":"PENDING","module_id":"WF-S2_40","module_kind":"WORKFLOW","outputs":["review/issue_ledger.final.json","review/assumption_ledger.json","review/llm_usage.jsonl","candidates/by-content-digest//","review/review_requests/.json","final/claim_relief.md","final/claim_cause.md","final/pleading_draft.md","final/stage2_package.json","commit/commit_intent.json","commit/stage2_commit_result.json","control/run_status.json"],"owner":"Stage_2_S2_40_owner","path":"workflows/S2_40_final_review_render_and_commit.yml","produced_schema_ids":["stage2_s2_40_candidate_manifest.v1","stage2_s2_40_commit_intent.v1","stage2_s2_40_commit_result.v1","stage2_s2_40_package.v1","stage2_s2_40_run_status.v1"],"schema_version":"stage2_workflow_contract.v1","scope_predicate":"workflow_id == S2_40 and entry_route in {TO_S2_40,TO_S2_40_STATUS_ONLY}","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ab1e5f593db41c1f26f9510c00d657221da53d08f011b2c4cf341a764a18d874","size_bytes":4415,"status_only_exact_inputs":["ingress/ingress_status.json","ingress/technical_diagnostic.json","ingress/stage1_input_manifest.json","ingress/intake_report.json","review/issue_ledger.base.json"]},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_resolver_source_lock.txt","mirror_sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","mirror_size_bytes":14423,"module_id":"TEST-S2_00-RESOLVER-SOURCE-LOCK","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_resolver_source_lock.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == resolver_source_lock","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"51bc1b310d40f5068df0a66446e5b96b00ea9b5b0137ddaf563caadf9f8fc51e","size_bytes":14423},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_schema_hash_and_signals.txt","mirror_sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","mirror_size_bytes":12842,"module_id":"TEST-S2_00-SCHEMA-HASH-SIGNALS","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_schema_hash_and_signals.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == schema_hash_signals","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"14207eedd80caaf24d85377617fb754bdeecc80ba9b2a291d6ac5d09ab0a6191","size_bytes":12842},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_conservation.txt","mirror_sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","mirror_size_bytes":5562,"module_id":"TEST-S2_00-CONSERVATION","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_conservation.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == conservation","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"c906dff7e11678a60556818d1baf24e66844d9c982c9d333ec339d2ed9ca6061","size_bytes":5562},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_canonical_ids.txt","mirror_sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","mirror_size_bytes":2275,"module_id":"TEST-S2_00-CANONICAL-IDS","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_canonical_ids.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == canonical_ids","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"c463506a90859daeef7eafddc4a6c08c563e2ae73200d921c1f00efb7bc24361","size_bytes":2275},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_cluster_bundle_compile.txt","mirror_sha256":"1b7a58ae53e7465cd39f0c911c4fab8e96b9e89df707eb9423e8a22fabc0a54b","mirror_size_bytes":25874,"module_id":"TEST-S2_00-CLUSTER-BUNDLE","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_cluster_bundle_compile.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == cluster_bundle_compile","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"1b7a58ae53e7465cd39f0c911c4fab8e96b9e89df707eb9423e8a22fabc0a54b","size_bytes":25874},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["FIXTURE-FAMILY"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_failure_and_atomic_publish.txt","mirror_sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","mirror_size_bytes":25937,"module_id":"TEST-S2_00-FAILURE-ATOMIC-PUBLISH","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_failure_and_atomic_publish.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == failure_atomic_publish","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"613f0c1b32dc26c302365fc62f36c8ede7204e1ced4920e797a1651af8354527","size_bytes":25937},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":[],"module_id":"P00","module_kind":"LLM_PROMPT_CONTRACT","outputs":["STATIC_PREFIX_SEGMENT"],"owner":"Stage_2_prompt_owner","path":"prompts/P00_system_and_safety_contract.md","produced_schema_ids":[],"schema_version":"stage2.prompt_contract.v1","scope_predicate":"static_prefix_segment == P00","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P00"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P00"],"module_id":"P10","module_kind":"LLM_PROMPT_CONTRACT","outputs":["STATIC_PREFIX_SEGMENT"],"owner":"Stage_2_prompt_owner","path":"prompts/P10_legal_resolution_contract.md","produced_schema_ids":[],"schema_version":"stage2.prompt_contract.v1","scope_predicate":"static_prefix_segment == P10","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"cafaab3991b8bd4ef3c95e55ce4c0649794c6eed9479d46d8c7758a4b823569b","size_bytes":8712},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-EC-00_CONTRACT_GENERAL","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/EC-00_contract_general.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/EC-00_contract_general.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8","size_bytes":3789},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-01_JURISTIC_ACT_VALIDITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-01_juristic_act_validity.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-01_juristic_act_validity.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99","size_bytes":3808},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-02_CONTRACT_MONEY_CLAIM","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-02_contract_money_claim.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-02_contract_money_claim.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824","size_bytes":3784},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-03_PARTIES_LIABILITY_SUCCESSION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-03_parties_liability_succession.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-03_parties_liability_succession.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c","size_bytes":3799},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-04_UNJUST_ENRICHMENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-04_unjust_enrichment.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-04_unjust_enrichment.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7","size_bytes":3725},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-05_TORT_GENERAL","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-05_tort_general.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-05_tort_general.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a","size_bytes":3694},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-06_PROFESSIONAL_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-06_professional_liability.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-06_professional_liability.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15","size_bytes":3724},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-07_CONSTRUCTION_DEFECT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-07_construction_defect.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-07_construction_defect.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9","size_bytes":3710},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-08_LEASE_DEPOSIT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-08_lease_deposit.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-08_lease_deposit.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db","size_bytes":3678},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-09_REGISTRY_TRANSFER_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-09_registry_transfer_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-09_registry_transfer_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002","size_bytes":3800},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-10_SECURED_REGISTRY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-10_secured_registry.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-10_secured_registry.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba","size_bytes":3757},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-11_POSSESSION_VINDICATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-11_possession_vindication.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-11_possession_vindication.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf","size_bytes":3724},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-12_CO_OWNERSHIP_BOUNDARY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-12_co_ownership_boundary.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-12_co_ownership_boundary.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a","size_bytes":3712},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-13_CREDITOR_PRESERVATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-13_creditor_preservation.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-13_creditor_preservation.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45","size_bytes":3826},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-14_EXECUTION_LINKED_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-14_execution_linked_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-14_execution_linked_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7","size_bytes":3787},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-15_SUCCESSION_FAMILY_PROPERTY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-15_succession_family_property.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-15_succession_family_property.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766","size_bytes":3763},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-16_NEGOTIABLE_INSTRUMENTS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-16_negotiable_instruments.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-16_negotiable_instruments.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194","size_bytes":3738},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-17_LABOR_WAGE_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-17_labor_wage_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-17_labor_wage_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea","size_bytes":3728},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-18_ORG_RESOLUTION_STATUS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-18_org_resolution_status.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-18_org_resolution_status.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f","size_bytes":3763},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-19_INSURANCE_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-19_insurance_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-19_insurance_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c","size_bytes":3685},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-20_IP_CLAIMS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-20_ip_claims.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-20_ip_claims.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1","size_bytes":3654},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-21_MEDIA_PERSONALITY_RIGHTS","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"registry/substantive/E-21_media_personality_rights.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == registry/substantive/E-21_media_personality_rights.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c","size_bytes":3803},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-E-00_RESIDUAL_UNROUTED","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/E-00_residual_unrouted.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/E-00_residual_unrouted.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39","size_bytes":3752},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X1_NOTICE_LIFECYCLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X1_notice_lifecycle.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X1_notice_lifecycle.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef","size_bytes":3693},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X2_ASSET_IDENTITY_LINEAGE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X2_asset_identity_lineage.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X2_asset_identity_lineage.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad","size_bytes":3742},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X3_PROCEDURE_STANDING_RELIEF","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X3_procedure_standing_relief.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X3_procedure_standing_relief.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df","size_bytes":3788},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-X4_RESPONSE_ADMISSION_DEFENSE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/crosscut/X4_response_admission_defense.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/crosscut/X4_response_admission_defense.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e","size_bytes":3793},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-AUTO_MOTOR_VEHICLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-AUTO_motor_vehicle.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91","size_bytes":3762},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-INDUSTRIAL_ACCIDENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f","size_bytes":3750},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-PRODUCT_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-PRODUCT_LIABILITY.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53","size_bytes":3737},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-RESIDENTIAL_LEASE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-RESIDENTIAL_LEASE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7","size_bytes":3739},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-COMMERCIAL_LEASE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-COMMERCIAL_LEASE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e","size_bytes":3769},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-LABOR","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-LABOR.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-LABOR.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a","size_bytes":3694},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-STATE_LIABILITY","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-STATE_LIABILITY.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-STATE_LIABILITY.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3","size_bytes":3747},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-PATENT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-PATENT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-PATENT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066","size_bytes":3709},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-COPYRIGHT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-COPYRIGHT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-COPYRIGHT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78","size_bytes":3728},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-IP-OTHER","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-IP-OTHER.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-IP-OTHER.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8","size_bytes":3746},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-MEDIA","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-MEDIA.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-MEDIA.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c","size_bytes":3705},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-TRANSPORT_MARITIME","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-TRANSPORT_MARITIME.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456","size_bytes":3835},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-SL-CONSUMER_CONTRACT","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/special_law/SL-CONSUMER_CONTRACT.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7","size_bytes":3797},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-MORTGAGE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-MORTGAGE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-MORTGAGE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d","size_bytes":3739},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-MORTGAGE-CREATION","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee","size_bytes":3771},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-ENCUMBERED-TRANSFER","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179","size_bytes":3828},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-PRESERVED-CLAIM-BUNDLE","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5","size_bytes":3816},{"asset_version":"stage2.bundle.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["P10"],"implementation_status":"DRAFT_UNVERIFIED_HASH_BOUND","incompatible_module_ids":[],"inputs":["P10","TYPED_STAGE1_CONTEXT"],"module_id":"PROFILE-ACTIO-DEFENSE-MAP","module_kind":"LLM_CONTEXT_PROFILE","outputs":["ACTIVE_PROFILE_CONTEXT"],"owner":"Stage_2_profile_owner","path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","produced_schema_ids":[],"schema_version":"stage2.llm_context_profile.v1","scope_predicate":"release_selected_profile_path == profiles/overlays/ACTIO-DEFENSE-MAP.yml","semantic_review_status":"PENDING_LEGAL_REVIEW","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191","size_bytes":3810},{"asset_version":"s2_00.build.1.2","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"dependency_module_ids":["SCHEMA-DEPLOYMENT"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":["AUTHORING-AGENT-YAML"],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_00_inline_projection.txt","mirror_sha256":"e28619d262d2870e93ae94bdd3b5cafd357a1c9047f3115811e1e0de62894676","mirror_size_bytes":39188,"module_id":"BUILD-S2_00-INLINE-PROJECTION","module_kind":"BUILD_TOOL","outputs":["DEPLOYMENT-AGENT-PROJECTION","FULL-CODE-MIRRORS","INLINE-CODE-RECEIPT"],"owner":"Stage_2_release_build_owner","path":"offline_build/build_s2_00_inline_projection.py","produced_schema_ids":["stage2_s2_00_inline_code_receipt.v2"],"schema_version":"offline_projection_builder.v1","scope_predicate":"build_target == S2_00_INLINE_AGENT","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"e28619d262d2870e93ae94bdd3b5cafd357a1c9047f3115811e1e0de62894676","size_bytes":39188},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"dependency_module_ids":["BUILD-S2_00-INLINE-PROJECTION","SCHEMA-DEPLOYMENT","WF-S2_00"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["AUTHORING-AGENT-YAML","DEPLOYMENT-AGENT-PROJECTION","FULL-CODE-MIRRORS"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_inline_code_parity.txt","mirror_sha256":"325e0ed4dc7a4562b87946f2ff68693865997bd33b55ce5d0a6c558920404a18","mirror_size_bytes":17586,"module_id":"TEST-S2_00-INLINE-CODE-PARITY","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_inline_code_parity.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == inline_code_parity","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"325e0ed4dc7a4562b87946f2ff68693865997bd33b55ce5d0a6c558920404a18","size_bytes":17586},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"WF-S2_10","module_kind":"WORKFLOW","outputs":["WF-S2_10"],"owner":"Stage_2_S2_10_owner","path":"workflows/S2_10_domain_relief_resolution_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["WF-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"AGENT-S2_10-HYBRID","module_kind":"LLM_AGENT","outputs":["AGENT-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"agent_scripts/Stage_2_S2_10.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"SCHEMA-S2_10","module_kind":"JSON_SCHEMA","outputs":["SCHEMA-S2_10"],"owner":"Stage_2_S2_10_owner","path":"schemas/s2_10.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["AGENT-S2_10-HYBRID","SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"BINDING-S2_10-HYBRID","module_kind":"DEPLOYMENT_BINDING","outputs":["BINDING-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"deployment/stage2_s2_10_llm_binding.yml","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","size_bytes":7287},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["AGENT-S2_10-HYBRID","P00","P10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"PROMPT-PROJECTION-S2_10","module_kind":"BUILD_RECEIPT","outputs":["PROMPT-PROJECTION-S2_10"],"owner":"Stage_2_S2_10_owner","path":"manifest/s2_10_inline_prompt_projection_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_10_agent_projection.txt","mirror_sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","mirror_size_bytes":68381,"module_id":"BUILD-S2_10-HYBRID","module_kind":"BUILD_ONLY","outputs":["BUILD-S2_10-HYBRID"],"owner":"Stage_2_S2_10_owner","path":"offline_build/build_s2_10_agent_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"offline_build/validate_s2_10_contract.txt","mirror_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","mirror_size_bytes":63811,"module_id":"VALIDATOR-S2_10","module_kind":"BUILD_ONLY","outputs":["VALIDATOR-S2_10"],"owner":"Stage_2_S2_10_owner","path":"offline_build/validate_s2_10_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_agent_contract.txt","mirror_sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","mirror_size_bytes":8076,"module_id":"TEST-S2_10-AGENT","module_kind":"TEST","outputs":["TEST-S2_10-AGENT"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_agent_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0a7b41894733b743d11ff88f0817a87bdbc98be317d8b3410baa8e9401b5b7bd","size_bytes":8076},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_wave_dispatch.txt","mirror_sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","mirror_size_bytes":9894,"module_id":"TEST-S2_10-DISPATCH","module_kind":"TEST","outputs":["TEST-S2_10-DISPATCH"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_wave_dispatch.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f7e59189ed93585c16c55943f7cc3ed464091fb23a9ea086e6e209cf14677a48","size_bytes":9894},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["SCHEMA-S2_10","VALIDATOR-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_domain_verdict_contract.txt","mirror_sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","mirror_size_bytes":10242,"module_id":"TEST-S2_10-DOMAIN","module_kind":"TEST","outputs":["TEST-S2_10-DOMAIN"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_domain_verdict_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9f2547a8c590b7df2aa09d0c3808766bf16be321a448742020d9a3476e7d837f","size_bytes":10242},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["PROMPT-PROJECTION-S2_10"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_prompt_cache_and_boundaries.txt","mirror_sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","mirror_size_bytes":11365,"module_id":"TEST-S2_10-PROMPT","module_kind":"TEST","outputs":["TEST-S2_10-PROMPT"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_prompt_cache_and_boundaries.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b77e63b19ba5a843df88180a5e7ac0441256682ea9aa92dc490415a75f1dcee5","size_bytes":11365},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":["BINDING-S2_10-HYBRID"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"mirror_byte_parity":true,"mirror_path":"tests/s2_10/test_release_adapter_retry.txt","mirror_sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","mirror_size_bytes":10848,"module_id":"TEST-S2_10-RELEASE","module_kind":"TEST","outputs":["TEST-S2_10-RELEASE"],"owner":"Stage_2_S2_10_owner","path":"tests/s2_10/test_release_adapter_retry.py","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"2a6a3119608b6063137575d66b8552623f164dbdd0952bc97074d6f687fb32e0","size_bytes":10848},{"asset_version":"s2_10.hybrid.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3","RAW-STAGE1-REREAD"],"implementation_status":"IMPLEMENTED_OFFLINE_VERIFIED","incompatible_module_ids":[],"inputs":["S2_10-HYBRID-CONTRACT"],"module_id":"REGRESSION-MANIFEST-S2_10","module_kind":"TEST_MANIFEST","outputs":["REGRESSION-MANIFEST-S2_10"],"owner":"Stage_2_S2_10_owner","path":"tests/fixtures/s2_10/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_10_hybrid_asset.v1","scope_predicate":"workflow_id == S2_10","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6fe7bac0fb2b87e4ff3535c9bfa78531aff91af4cc1142a09035225b95581e3d","size_bytes":2572},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-F82ABBC2137A8ABF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/build_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"57fbf8c3f5f86f00db668c425c3e07de74e9d5820b71975c4da3a3bff32e036d","size_bytes":1871},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-F8EF2F640FB77AD1","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/chunk_manifest.jsonl","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"fd3e1ba067b5960e1d3dba1b5107de913d45ba2b3732a28c3870b10105761b67","size_bytes":620},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-787106ABBFAF8931","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/source_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ce3ce207ed274292499630a0813d4bdb6a66baf26710fb0e883c2e405adb9a67","size_bytes":807},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3CD8C31D78EBF47F","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"corpus/weaviate_collection.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f29b287e99d29dbd6d3008d1ad68e3960f9cc2c72459f04316f0311cd3e9a47d","size_bytes":18104},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E852EAB9373DF086","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"law_values/court_fee_values.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d1213e58b0de3b728945134e0a00a71565fee6db9077c932d7ee99da506c1115","size_bytes":912},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-309310FEC8A6178F","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"law_values/general_law_values.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"45ad98e9e93090fbc5e5c7037f404bd86ff89b73a4aaf8c3449d226bd2aacd1c","size_bytes":843},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-060B74A3C012D23C","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/authority_release.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967","size_bytes":1068},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B51F7A86E15908DD","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_coverage.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"34d6f758fc1486fa7330ede376e65b9448a6eaa971bd21472b0e4b7d9a5b8cba","size_bytes":143780},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-16A7CA30B83DD493","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6462217f08ced21693e8cfc812182cfc1da593d52e719e5cd11ef30409ffd00e","size_bytes":80525},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-34A6FBBE9101F1E8","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/case_type_rule_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ef42e873f497e1e2cfdf9440207f7caaa1f55462a3d47dc207b3c20f9c102793","size_bytes":56945},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3051DBC07D975B39","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/corpus_release.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"27d0c83e7a95342efdbe5be675b6d5b7d0ff8695eeec022ebc5aded3359fc981","size_bytes":920},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-98D409BCD1DE68FA","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"manifest/s2_20_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"19822af8fd0245c84b303955106c99ebdfcb5bbce06e76602178c90d4ecf6e82","size_bytes":5443},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-672D5EBD9C1F8AE0","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"migration/actio_assets_receipt.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0d1a3b5eaa7ea670f76db0baa8c30e23b4367904c3f715145737f1dff22f9204","size_bytes":10407},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2B7093A6A3B291AF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"migration/legacy_asset_disposition.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1b0c6b3bafd8bb11ec90e809d0fce057fec83fb12b1f9976471f8952ce073f2c","size_bytes":6039},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_authority_law_value_release.txt","mirror_sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","mirror_size_bytes":7213,"module_id":"S2_20-ASSET-E3CE7EC9216DDBD3","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_authority_law_value_release.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8c1d9b2f05fa752d50349ed1a4479aafcb17c2f574fa1ebe6b19d2bedc21ffeb","size_bytes":7213},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_corpus_snapshot.txt","mirror_sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","mirror_size_bytes":9781,"module_id":"S2_20-ASSET-5F7DB1273D883DE5","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_corpus_snapshot.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"96feead66f24d375b9ac379f459de040a9ae1f368e9c05d2911c5b0da54c02c2","size_bytes":9781},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_release_manifests.txt","mirror_sha256":"149e419021b7faf9e7d8d7799f5ce3c75b209ce6155ec503dd2d2197ee45bc7b","mirror_size_bytes":30787,"module_id":"S2_20-ASSET-6CE2AD14244F5B49","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_release_manifests.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"149e419021b7faf9e7d8d7799f5ce3c75b209ce6155ec503dd2d2197ee45bc7b","size_bytes":30787},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_20_inline_projection.txt","mirror_sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","mirror_size_bytes":27865,"module_id":"S2_20-ASSET-86DCA2BCA2270252","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/build_s2_20_inline_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b5c035251621920dd848d672dc6cf840500ce2b60e1e6656f021855681f6fc58","size_bytes":27865},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/compile_case_type_registry.txt","mirror_sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","mirror_size_bytes":9658,"module_id":"S2_20-ASSET-A360A270415B6E16","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/compile_case_type_registry.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e415b5179e53f5a7e35e5e1b7749706c783fbf296bf0bf40103e9450df0b2f0c","size_bytes":9658},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/compile_relief_rule_projection.txt","mirror_sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","mirror_size_bytes":42682,"module_id":"S2_20-ASSET-B57CC23FD4D06275","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"offline_build/compile_relief_rule_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8412f2ad7b8de4738fbb86a7596def90dbc9d34d4e2f24854e964df476589c2f","size_bytes":42682},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-DDC65130DFBDBA55","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/binding/binding_signature_projection.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b4317d0a5adc3f2bc70214c3e98c4f885ecfd26e36d8242221db4971b6f53142","size_bytes":835},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-AA1E72AB254FE6DC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-01_interest_delay.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d0d180a8f8af72d7dda5134b521122827fd2d1f9055c10d35ef5881d7d8cea53","size_bytes":1503},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-45939B38FC8F0B28","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-02_allocation_setoff_balance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"19a6a32b5879f20ed36df149cdbfb40ec2b5835152579e90a396f745e6299772","size_bytes":1511},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-A4DAC30C3F1AC365","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-03_limitation_deadline.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1dc66a75034576a41be43058ac421f5c8188288da9928df4d5b9cf616a819ea7","size_bytes":1515},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-D9EEBF8449D85E04","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-04_valuation.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e83044bfd16167cc6c1028afa06b0dc041e0114cee72379563047cff9fbeba11","size_bytes":1483},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BC815891D9220145","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-05_personal_injury.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0f197813d298f87010545d6eb09c4107c13303b6eb83d276e0130e25abaa7b00","size_bytes":1512},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2A85ED56A7C1242A","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-06_construction_defect.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1626c6673b7381e00fa61b7724ae63c8b10cb2ddd932040edc5f69889ffe5ab3","size_bytes":1522},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-6E799BF3C28471BC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-07_lease_use_gain.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f05c94ad80280607664a1ddcbd29367d0164333888c0d744dd674bf21cee3fad","size_bytes":1488},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3F219FD043EF4AE1","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-08_inheritance_reserved_share.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"330a1e5f72e4a4e4b7da096ceae554312ca2f828363b761ed37af37abf281818","size_bytes":1518},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BCAEF55DAB2126D1","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-09_wage_severance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"dba73da63069e89f95550419d989da78f8fe10196b052c49f050466a0dcda5b9","size_bytes":1489},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-81B84BD832C992EF","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-10_actio_insolvency_value.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c8710d3e9292b95e53d834006e784b13669b9023149e26628d0abaff074c1c85","size_bytes":1532},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-2852DF1EC788C440","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-11_distribution_share_division.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4b3c8161ae779628575e122f1f602d6bee40b387c402c5ce642692796e1ab369","size_bytes":1512},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-FD4E3378C53FDCB5","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-12_insurance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"66d58d2043e45966df9db6c89e980f3c91cbdd6fcf4a4d96944fc203abedf532","size_bytes":1503},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-22371F1936240951","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-13_court_value_cost.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6f914553fd25a9ecb28d85070c2c0ddbf41178906f9075092f9d174977073824","size_bytes":1539},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-711DD22CD3721D81","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R1_ip_damage.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d33b7963d68cee10281da86e465caed152e3f69493728a563bca69c6dfb18c2b","size_bytes":1482},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B585B054934C1C1D","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R2_org_liquidation.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3bb03e07ba28a01d8c9e3944df55fbc43b21e17435bfa5e84ec60ef7b1540991","size_bytes":1513},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E032EAE75B122995","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R3_transport_maritime.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e64e808a4d1637c991f1ab512fad25f51637ecba3b2b0dfa66abb7efb8504c7e","size_bytes":1508},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-ED6526C35FE96ACC","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/CE-R4_financial_instrument.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0198a5d09f9b75dd3b6978a01c9a8a3e468c8dd305c49721ae04ce93954b72d3","size_bytes":1510},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B0A8A8F08ECBF0AA","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/calculations/calculation_activation_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1a152af7e0ed4ee2ce10ab93bf3be343122f95e9f276585433449bde27c46e55","size_bytes":5540},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-69ADD915C1858F49","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/corpus/requirement_fact_scope.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6b38306dd4657df2c929caeb1b71bf78838f628e99018fff4692bacf4d49e2c1","size_bytes":216},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-A416DC6DB820828C","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/case_type_relief_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"01f95c0c1a95f80bfde1ee9c166ffb3ab1f22339ee035f5c322e2637329b8214","size_bytes":1416},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B8BE6EC64CED552C","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/counter_performance_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5c9e274f38fcfa4e8bfcb0938d2274b8dd83a6f8dac874de3c237b7a2608ab43","size_bytes":857},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5FDE95EE5314FCA7","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/forbidden_relief_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"fb51bec7b741e983a5e6f59f8265f3818c49f8067323e9b2090673a832eaae22","size_bytes":852},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8CDFE6C311F7F7D3","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/drafting/procedural_declaration_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3328d71a3fb020024fa8a0f8592788d409845d5ca0e2ca9a2b6c63ed3530147c","size_bytes":864},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-4414670A81E95DEA","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/party/party_set_rules.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"92b1b8b76a396008629f534fdcd63995733ccdd71d6b2d9f9c4ad7360daf0c0a","size_bytes":225},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E1D9BDC792A7848D","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/planning/option_disposition_policy.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f3a656c3c1c0eabd22d26e4d3c9f541459af05727f595646a2f7a59d5c5e7658","size_bytes":426},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-CD373B0725950922","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/regression/finding_fixture_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"53c92c6b77c85d280aaa37ae5cc4fc355b3ee3e76c55bd87852bd25636f22992","size_bytes":8520},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-809C3C709B4F2295","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/review/review_policy_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"15b3181f7236f9500aea4699a95c71811761add2712eb4a5c4f8cbce11d4ef87","size_bytes":2301},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8EC84AB1A8C873B2","module_kind":"DECLARATIVE_REGISTRY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"registry/temporal/inheritance_reserved_share.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ca37eb894d04dcba604fe4656f941c44d76fafa1c221f4ffcdd988419a81d7a0","size_bytes":928},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"release_ops/canary_rollback.txt","mirror_sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","mirror_size_bytes":1345,"module_id":"S2_20-ASSET-2040ED84718FA22C","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"release_ops/canary_rollback.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"327356b4f59bb850fcfb680d5caf13038025e3042689f11e1018731058d15241","size_bytes":1345},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"release_ops/release_validator.txt","mirror_sha256":"fa6777fb28554498df57666d393a380ff0a00d52a11bc3e7166010547e4d391d","mirror_size_bytes":55349,"module_id":"S2_20-ASSET-DBB6C2CCD4AB3FA2","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_20_owner","path":"release_ops/release_validator.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"fa6777fb28554498df57666d393a380ff0a00d52a11bc3e7166010547e4d391d","size_bytes":55349},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-52C4FB90CB0F9E68","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R01_money_payment.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"98f06696a8c090078b2b4b72e8f25c6ecac342fbdafecfa4024d9f1bef7d6bbf","size_bytes":1844},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B031219CDF7A06DF","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R02_delivery_possession.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"42d9654604aedd4dcbd6724b7960b0c42d281ec775c3a6c635941dd06abc564d","size_bytes":1781},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-7BEB573DD33365A1","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R03_declaration_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ff0e90951b373b662fafe70aa28fdff001b6c3a571180bb2d7537c23a0e4b641","size_bytes":1813},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-769585D81F81F620","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R04_special_nonmoney_performance.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d1368fab9b91fadf3da0e864941708b7d82a39cda7110723f6a712489b9f014a","size_bytes":1875},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-04C3EF62029B522C","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R05_declaratory.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e903cd34bdf2e48479e5248a9ac120885dc612b27e34b5c9e2b6ce29c8cb89f5","size_bytes":1802},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-BFC589A870A04F07","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"renderers/R06_constitutive_judgment_challenge.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ada485d34b696a8d4e59d85d9e0d22a9f510448813ffa7985700b778581fcaaf","size_bytes":1840},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B2C88C2FFDE4487E","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"routing/actio_pauliana_mortgage_route.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"209fce4f610e7eb6c6ddc2995163de59537ca546752187c23dd1b417e2b117ec","size_bytes":721},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-DD9ABC431EB1B8BC","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"routing/actio_pauliana_route_registry.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f30550aca6ce2a453bd39498d81653eb257cffcd6c693ba56b62f698a510427c","size_bytes":906},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/authority/authority_preflight.txt","mirror_sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","mirror_size_bytes":2115,"module_id":"S2_20-ASSET-2317885DE36C87BB","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/authority/authority_preflight.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ffa513bdc7ddb1de895b4e813de9e107c94c36a5955166c7d5cee745584d0dda","size_bytes":2115},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/binding_signature_projection.txt","mirror_sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","mirror_size_bytes":5843,"module_id":"S2_20-ASSET-2B67B561F6C4FD3B","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/binding_signature_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0ea048355b4abf8cf261bc60735a557ab09d84e325aa42bd4d7acb58f589c6b5","size_bytes":5843},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c25_case_type_bind.txt","mirror_sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","mirror_size_bytes":3471,"module_id":"S2_20-ASSET-2EABAE08AAE777EA","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c25_case_type_bind.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"7cda9812225379ef92c34b8ca383aa35bdcbac6afc30b3a21245f5e3ad6aa3af","size_bytes":3471},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c26_rule_branch_bind.txt","mirror_sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","mirror_size_bytes":5089,"module_id":"S2_20-ASSET-FCA7B87C74F0BB44","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c26_rule_branch_bind.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f6d6fb87b005b0a155e24ae93c7550640bfdaa221063af034c3d3e20b46cc6b6","size_bytes":5089},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c27_query_plan.txt","mirror_sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","mirror_size_bytes":6553,"module_id":"S2_20-ASSET-1327E50515C73062","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c27_query_plan.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"d7fe404438e185b2e0351b8b5ac8fc7bd911a63544e71c7c16ffb313dc566777","size_bytes":6553},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c28_weaviate_retrieve.txt","mirror_sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","mirror_size_bytes":12083,"module_id":"S2_20-ASSET-4AE83266D12B501B","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c28_weaviate_retrieve.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9634c80dd1b77ab652185ef5bd2b67ccbb7d355d2b4661f67d86fa78d0ee6395","size_bytes":12083},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c29_pack_verify.txt","mirror_sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","mirror_size_bytes":5721,"module_id":"S2_20-ASSET-0A121BEB45A15E4D","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/c29_pack_verify.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4318f95c9c38391a455613b7411cee923288d19748f3c0946e86c588be718b9d","size_bytes":5721},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/calculators/registry_engine.txt","mirror_sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","mirror_size_bytes":11417,"module_id":"S2_20-ASSET-FE154EB4E8F19440","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_20_owner","path":"runtime/calculators/registry_engine.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"173da5185caa6d4a82a7735018c9121ef42481cad8d83b9574c9f432912c556d","size_bytes":11417},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-E82839694073D431","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/binding_retrieval.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"25df409822a45fd26d0c5cf46e4afb55af100765c86afa148046354b2f02c8dc","size_bytes":47811},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-C9FC917D8CBF920E","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/calculation.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"7036793fe6c8d3550ca22486c281b1ffdbb915995dbe17c92d98a3f9a8f194ce","size_bytes":33698},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5D843BA99044953C","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/domain_verdict.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5fec56a0661e2ab2351d92939c4fbdedc8ac4c7e8699dc92caae7dd359c7eb16","size_bytes":1262},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-FF1F03B3FC56E579","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_20_owner","path":"schemas/relief_plan.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ef5d271e981390421fa7a188c01e52b390ab138bfc32203056f59d7ab6dfc8f2","size_bytes":31558},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-9A06594587743420","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/actio_route_cap_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f922b3ec10cc1da44c62d6ca5cf9c8ec5a53f5328b1eaabf236db46448907ca8","size_bytes":572},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-3ECDA3121E0AE910","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/calculation_temporal_boundaries.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a31af03c418466b1dfc05f47ea05b58109fe142b813da2b3a8863e9d5f71004d","size_bytes":1612},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-5EB4DEF644C02B9D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/case_type_rule_binding_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"45e0f7470e2907d20d6359d192fe8320051bf8a278f8eaa8153fbe964819685c","size_bytes":1042},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-60AF7FED54CBA5C1","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/case_type_zero_multi_hash_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0fbe5f68f4e60dfdd4fd03b9f6f076526f1b3d273b328ec853e69b4f9c315180","size_bytes":1123},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-49D464EEB3D65FFB","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/minimal_supported_portfolio.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"4bcbcf19019e086e4eb4772cb55e87832c3a68c4829f67d50c6a7318dda79c86","size_bytes":733},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-97F26683DEAEA7F7","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/mixed_option_dispositions.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"509f3f436c8107c03033324413560b706487279bf91f2e231bd43bbc5c86b8e0","size_bytes":1457},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-8A3BBD97738BC0BF","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/plan_publish_barrier_failure.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"29afbbdfa609234b06473542c35df7083ca6313155456cc6d1ec311fd50ea275","size_bytes":1640},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-47A96BFDC0754003","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"2a1a163d62a041990d71feaef54f3c56753ea3aa02666d3dc4c631552f7ee746","size_bytes":15014},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-B42FA1C2AD23D1BA","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/fixtures/s2_20/retrieval_replay_injection.json","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"8fbed161a30d52d8f5018f238dbf2cd01e0dd84162c97e3293df62d82a7ca804","size_bytes":1338},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_agent_and_inline_parity.txt","mirror_sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","mirror_size_bytes":2773,"module_id":"S2_20-ASSET-E1B1709F62DB7D8A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_agent_and_inline_parity.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0f73c112b28088be191b6717cb24cac468762cc286f8dc806bf65d98a95bf262","size_bytes":2773},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_calculation_and_reports.txt","mirror_sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","mirror_size_bytes":3199,"module_id":"S2_20-ASSET-1D1B579AA031EC90","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_calculation_and_reports.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c1bd36c351173d25e6d8e68d1a90d738b90aabb51b201ca13f4370654e584e00","size_bytes":3199},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_inline_output_schema.txt","mirror_sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","mirror_size_bytes":43574,"module_id":"S2_20-ASSET-22C24679226830D0","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_inline_output_schema.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e2cb938dd639874a4b150997d66eacd89b22016c8fd3385a243edf781cd3e85b","size_bytes":43574},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_offline_compilers.txt","mirror_sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","mirror_size_bytes":20252,"module_id":"S2_20-ASSET-6FFF0ED2C88404C2","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_offline_compilers.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5e75f659a9e5add1345f1596c92c0b143cb1e48110c746a8785fb5b38f1371af","size_bytes":20252},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_option_group_and_binding.txt","mirror_sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","mirror_size_bytes":6171,"module_id":"S2_20-ASSET-E56589B5CCA0246C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_option_group_and_binding.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6021d93fb47377cf6c00ccb5a880a7e85987ec5a1ed7976a84baca2d7fb39985","size_bytes":6171},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_plan_publish_and_release.txt","mirror_sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","mirror_size_bytes":13950,"module_id":"S2_20-ASSET-2868A4B922737A76","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_plan_publish_and_release.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ce0dc52cca2c6744be1051346ebecabac8c4ccbd97d697f7645eadd35aebd1e8","size_bytes":13950},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_regression_manifest_closure.txt","mirror_sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","mirror_size_bytes":10028,"module_id":"S2_20-ASSET-0C03601E14F2D714","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_regression_manifest_closure.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"01ac49ab1ba79f158da9da78313407e3a67a95cf539113c617701a74c29b463f","size_bytes":10028},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_20/test_retrieval_and_pack.txt","mirror_sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","mirror_size_bytes":6654,"module_id":"S2_20-ASSET-A24AC597CB6DF548","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_20_owner","path":"tests/s2_20/test_retrieval_and_pack.py","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c314cf27511b0fe065b8961196084a28b1c7c5cb2fed3dd5c8765172ba40462f","size_bytes":6654},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-CAB87BA40B475A9D","module_kind":"S2_20_ASSET","outputs":[],"owner":"Stage_2_S2_20_owner","path":"validators/actio_value_compensation_invariants.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"591182a8869f3c0c0e03e9b32f5f0d9b856361b3f5f77f1e6e87eb0188f1ef22","size_bytes":983},{"asset_version":"s2_20.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_20-ASSET-AA40CF5140DE8790","module_kind":"WORKFLOW","outputs":[],"owner":"Stage_2_S2_20_owner","path":"workflows/S2_20_canonical_relief_plan_reduce.yml","produced_schema_ids":[],"schema_version":"stage2_s2_20_generic_asset.v1","scope_predicate":"workflow_id == S2_20","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"da56152af502fe432cb2ebaa593a4e389b7f2cd4d0b8f3be29e49717cff0544a","size_bytes":2443},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-871DF298A294D7DC","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"manifest/s2_30_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e4b734e354f4184dabe5984ed419f64636fc8a8daef12f6542ff960b2c7ab749","size_bytes":1603},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_30_agent_projection.txt","mirror_sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","mirror_size_bytes":56585,"module_id":"S2_30-ASSET-66EF7EC35105D464","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_30_owner","path":"offline_build/build_s2_30_agent_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/validate_s2_30_contract.txt","mirror_sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","mirror_size_bytes":104292,"module_id":"S2_30-ASSET-7E89202630AA3B4A","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_30_owner","path":"offline_build/validate_s2_30_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E83A5821C44AAF21","module_kind":"S2_30_ASSET","outputs":[],"owner":"Stage_2_S2_30_owner","path":"prompts/P30_joint_drafting_contract.md","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-6A9B1F5EC854740E","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_30_owner","path":"schemas/draft_atoms.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5107b64f01ffb3633a829c10652747760a5035c9cc07227c546e3f543005eda9","size_bytes":68470},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-546763E72E7A932F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/adverse_fact_worknote_policy.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5b8e9101385f8d65b0332c3be63cb9a22063920675cc86aee51e04da7820aef7","size_bytes":3444},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-47ECD04400C72037","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/cache_prefix_drift.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"845b44cfeb1246f16cd3458965683247efc360b166b31133e3286be400325f98","size_bytes":2109},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-9C7A8A9DC09BB101","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/context_reference_envelope.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a1d6ba9752b9d4fb479dfaaa763174988f38d87890db9487db9de556d3eade60","size_bytes":4804},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-0DA94639658F5DB2","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/counter_performance_and_declaration.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cfa3a8439ca938b05768798dfee39a3cc1e4980d5550526c787843622516da90","size_bytes":3322},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-CA60AEE03DF32752","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/follower_batch_dispatch.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3dffaf9862e15f2fe906ca63abb3be61e49177fb58abb4c4a7a8b25db4e4493b","size_bytes":2832},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-18231E85556C3220","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_forbidden_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a2308629fc09f75ab226b89374c78323f62a9dbe296aebdd83170a0cfb926e09","size_bytes":2741},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-8265AF415D892AB3","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_preassembled_prompt_item.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"6655402c669e5b40f2e7028a5c0c89571d8e1597dbdef567b4c9d8e2eed15a79","size_bytes":2204},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-A7A8934E5BF55C76","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/invalid_reference_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"eb2982a09f4948baadc27ae49c4f125426074333ea4a626e9c56ddc5c24ce273","size_bytes":2663},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-D8A8B0F06569C1F0","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/owner_singleton_dispatch.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"38f9c364591fcdfe60d0dea9f69eb86b2f3b883929f6d60d06a7c35ff376fca6","size_bytes":8448},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-7D7984D0B44475DA","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/partial_write_publish_barrier.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0d878b946ebf810e8d0d8da74af33e56f35e164b04076a3867344b95d5f953eb","size_bytes":3352},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-B1A866CA34AFBC11","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"43e5b20ef4389da9c03b8062ce8bfacf2cd880d2efa2a1cbe1e901f4111f64ea","size_bytes":3584},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E696214E5807E29A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/rule_requirement_admission_gap.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"27dfad63f3508c5d40521270707d84b2bc0c58f035f47d0cde1ae2abc54f9a15","size_bytes":4298},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-C8F5D82811189C0F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/technical_failure.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"bdcc6410e7515edc73d6b154d5b618b3ec34273ddc7269dc3e3ce55a6eb35fa6","size_bytes":2719},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-77E545820FEC15EC","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/valid_joint_draft_output.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"0135616c9375602693af8e12c3c16cf2031eaf3d9b74783bec9b5065846327e8","size_bytes":12982},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_agent_contract.txt","mirror_sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","mirror_size_bytes":12199,"module_id":"S2_30-ASSET-97349E7C166EE517","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_agent_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_dispatch_materialization.txt","mirror_sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","mirror_size_bytes":13911,"module_id":"S2_30-ASSET-748AB3E90AD4378F","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_dispatch_materialization.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_draft_atom_contract.txt","mirror_sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","mirror_size_bytes":10484,"module_id":"S2_30-ASSET-5165C83A0FB3CDEE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_draft_atom_contract.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","mirror_sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","mirror_size_bytes":6284,"module_id":"S2_30-ASSET-30A7574DB26A7700","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_prompt_cache_and_boundaries.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_30/test_release_adapter_retry.txt","mirror_sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","mirror_size_bytes":18566,"module_id":"S2_30-ASSET-A9BE2C9D380E8C50","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/s2_30/test_release_adapter_retry.py","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-E1FCF8BD63300F4D","module_kind":"WORKFLOW","outputs":[],"owner":"Stage_2_S2_30_owner","path":"workflows/S2_30_claim_group_draft_map.yml","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b266e7b7ae8939b087bfdb7b34fff8b9c6011c835560ab690991d856ced0cc15","size_bytes":15221},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-710AE87909AE0663","module_kind":"MANIFEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"manifest/s2_40_parent_member_paths.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"3ab6c0398f16d53542c115f2efa164f5ccfd1e64bf457b914a589c61321e8121","size_bytes":2257},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"offline_build/build_s2_40_inline_projection.txt","mirror_sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","mirror_size_bytes":36098,"module_id":"S2_40-ASSET-1CF70696C9F630A8","module_kind":"BUILD_ONLY","outputs":[],"owner":"Stage_2_S2_40_owner","path":"offline_build/build_s2_40_inline_projection.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c6dee2c30d4b23fa3e6aaf2cded4f933dae6e642c71eeff8534c4e53a12bdfe0","size_bytes":36098},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/c45_document_assembler.txt","mirror_sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","mirror_size_bytes":11992,"module_id":"S2_40-ASSET-5B0EE99ECD2C0599","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/c45_document_assembler.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"93135e69189a335f34be7c383cef2b5ca9f12ea899266b0d8ecc4bd85237647e","size_bytes":11992},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/rendering/closed_renderer.txt","mirror_sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","mirror_size_bytes":10559,"module_id":"S2_40-ASSET-0B59F323E4EACA18","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/rendering/closed_renderer.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"21acbee2e5456de2b647b5c235c4e8293b77a864af9bc365c75c8346d34070cd","size_bytes":10559},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"runtime/validation/invariant_runner.txt","mirror_sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","mirror_size_bytes":30951,"module_id":"S2_40-ASSET-8217116B75E9550A","module_kind":"RUNTIME_CORE","outputs":[],"owner":"Stage_2_S2_40_owner","path":"runtime/validation/invariant_runner.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"67d2ff35d66079fa7fe5e8f312f18ed68b16da5eb4f9f85780d11bd45b54009c","size_bytes":30951},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-66B24FF9775426E0","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_40_owner","path":"schemas/migration_regression.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"775a186df990e3704391876926540da911d64c56f76b0bee6c0b97c6cdb38e58","size_bytes":4610},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-5C4CAFFAB8D2F982","module_kind":"JSON_SCHEMA","outputs":[],"owner":"Stage_2_S2_40_owner","path":"schemas/package.schema.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c1cdf59d7273715276e38fe227c5dad5d7b825cc522118ff6ab2d1b3a342dd3c","size_bytes":19691},{"asset_version":"s2_30.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_30-ASSET-F261637CB908A41C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_30_owner","path":"tests/fixtures/s2_30/persisted_handoff_chain.json","produced_schema_ids":[],"schema_version":"stage2_s2_30_generic_asset.v1","scope_predicate":"workflow_id == S2_30","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"54d6d781a60640744cba4b9c2f88a0013a6e58656c9c80a809e39fd4ba7c1097","size_bytes":2016},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-19CB23FB1E5F99DE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/candidate_digest_noncycle.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"74885602909bd19ca1678de781cac26afd34c2f386e98fc0370fd6ff6fb7b8bf","size_bytes":798},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-9E10C878E97D6636","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/cost_provisional_execution_numbering.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"17c380492f5bc56ecf675cf9683784b2e463241c7d0589b7b496e7a381145c9b","size_bytes":2143},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-D73DC5121366E2DE","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/exhibit_object_party_title_completeness.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"40045822f45b2a57805504744e751ee420a6187d0790d5a0f442f529ffedcf7e","size_bytes":692},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-71BEFE2BDE251773","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/part_set_missing_duplicate_or_cross_group.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"379273497ee23d4a515135771ba4d3bb5ff0e38325ad40eb4e0a0008cd6b88f4","size_bytes":785},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-C245AA392434948E","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/partial_write_readback_barrier.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"467387c12a4cc6469d243de9f0a7948276adb558a99b3b661ccd74a5d17629cf","size_bytes":652},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-B77178D146E18FE6","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/regression_manifest.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"ac5d68c8d4061d789aa5c773cd1ffb37728c33c7725785a9dd1f4bea63ec88ce","size_bytes":7030},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-724CEBB85D0021D4","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/relief_cause_crossmatch_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e8d148fef61920039e36abd0cfb771cc6e2fe3aa1a9cc0b0b0502c38ddf70567","size_bytes":761},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-D8B6C423CA8B8343","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/renderer_ast_slot_branch_mutations.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e70ecac4e71de962dfe8bb025a42c73c7c03cfba32c29319523d19f49e8260d0","size_bytes":1800},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-ED81C6D9C14D5A6A","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_policy_state_aggregation.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"953fc301703ff353de4df3cf46ed4e90b6bf4ce8268b08705e16151ffc8c3a21","size_bytes":581},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-88DA222DF4B4AC40","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_approve_resume.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"c5b84e34358761750e8e9e7666de6532e0f22a31f32bf027f24efb256a1af5d5","size_bytes":983},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-45C755C76F2E9040","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_content_change_supersede.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"400d4aeb455e5c3ec26c75a552ea91e9af79cb2329998caa1ad72d1be18da8e7","size_bytes":627},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-60A3C7B6370B71D7","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/review_receipt_missing_or_invalid.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"a88645be90a9e0943358d83f7ea105193dd4b4dfebea4519702a17f69615dc65","size_bytes":688},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-010B031F043CFB13","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/same_binding_idempotence_and_commit_conflict.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5536793236fa44da601dc8cf65d94dac32b18ebc2e8dc525a6df92106add57ad","size_bytes":674},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-1FD9A637BC46671D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/v01_v18_invariant_matrix.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e4c0a5476647fa1860cd685a15aad6d465a36b4f6b648c8e2a066c8747780eb8","size_bytes":9096},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-CDB97542A2A4F866","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/valid_full_candidate_and_commit.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"e98e8dc55ab60f8f875ad2f58c1aec35eb1da3882371c22c3e232e0e9ae46c2f","size_bytes":1221},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"module_id":"S2_40-ASSET-01E38009C9220C87","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/fixtures/s2_40/valid_status_only_diagnostic.json","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"5676088f5d79168cbae5e1481da4b7cfd9241d06c935378e06dd2af56aae6285","size_bytes":724},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_agent_and_inline_parity.txt","mirror_sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","mirror_size_bytes":32947,"module_id":"S2_40-ASSET-A6B20D5A9A6882F5","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_agent_and_inline_parity.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"04cc4a14790eceea6ec8a9331212ca6e767ef96994b5b26483392d23145417ae","size_bytes":32947},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_c40_reduce_and_conservation.txt","mirror_sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","mirror_size_bytes":3032,"module_id":"S2_40-ASSET-46C37B9570DE79C8","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_c40_reduce_and_conservation.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f610eced056420277c67294cdfe76d559073d88a6f42d3e8c5dae8f219fa82d9","size_bytes":3032},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_c45_closed_render.txt","mirror_sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","mirror_size_bytes":7855,"module_id":"S2_40-ASSET-A2E1E4DAA289FE95","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_c45_closed_render.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"b7cad96735b1a0158644f41703b4f279fdd8b6bc68438f0d7d773b8415ebb460","size_bytes":7855},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_commit_barrier_and_idempotence.txt","mirror_sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","mirror_size_bytes":8228,"module_id":"S2_40-ASSET-6CFF5B81DB1AE376","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_commit_barrier_and_idempotence.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"714e2f05397d5dcc31159739363f11c9bbaf5a091de55b465e0b474c21f90ea0","size_bytes":8228},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_release_closure.txt","mirror_sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","mirror_size_bytes":12692,"module_id":"S2_40-ASSET-3309DF833726005D","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_release_closure.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"89139e0286facd52c3ce91a1c7b382a584dfc3e6bc337fcb55fbc8eed59f5933","size_bytes":12692},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_review_state_machine.txt","mirror_sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","mirror_size_bytes":8373,"module_id":"S2_40-ASSET-EDD6AFC9610DFC1B","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_review_state_machine.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"f4dab9bb651b4a3c818c73162b972c8ac3df0f50fbe056e392a12673139b9b4a","size_bytes":8373},{"asset_version":"s2_40.1","authority_ids":[],"consumed_schema_ids":[],"dependency_module_ids":[],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND_OFFLINE_ONLY","incompatible_module_ids":[],"inputs":[],"mirror_byte_parity":true,"mirror_path":"tests/s2_40/test_v01_v18.txt","mirror_sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","mirror_size_bytes":3853,"module_id":"S2_40-ASSET-A50D95FF51F9CA3C","module_kind":"TEST","outputs":[],"owner":"Stage_2_S2_40_owner","path":"tests/s2_40/test_v01_v18.py","produced_schema_ids":[],"schema_version":"stage2_s2_40_generic_asset.v1","scope_predicate":"workflow_id == S2_40","semantic_review_status":"PENDING_LEGAL_AND_LIVE_ADMISSION","sha256":"72be88be1aa9d495b5c9387e45b75e86f44ac76ffe15c04b5ba33ba21fa8943f","size_bytes":3853},{"asset_version":"s2_00.test.1","authority_ids":[],"consumed_schema_ids":["https://schemas.liti-agent.local/stage2/shared/deployment.schema.v2.json"],"dependency_module_ids":["SCHEMA-INGRESS","WF-S2_00"],"forbidden_contract_codes":["LEGACY-STAGE2-V0-V3"],"implementation_status":"DEV_HASH_BOUND","incompatible_module_ids":[],"inputs":["S2_00-REQUEST-ARGUMENTS","LOCALDOCS-SESSION"],"mirror_byte_parity":true,"mirror_path":"tests/s2_00/test_prepare_request.txt","mirror_sha256":"db76d064f742c2003eacfcb4814ba0b9d0b36984622147485cbab1139d5deaeb","mirror_size_bytes":6946,"module_id":"TEST-S2_00-PREPARE-REQUEST","module_kind":"TEST","outputs":["TEST-RECEIPT"],"owner":"Stage_2_test_owner","path":"tests/s2_00/test_prepare_request.py","produced_schema_ids":[],"schema_version":"pytest.v1","scope_predicate":"test_axis == prepare_request","semantic_review_status":"PENDING_CROSS_AUDIT","sha256":"db76d064f742c2003eacfcb4814ba0b9d0b36984622147485cbab1139d5deaeb","size_bytes":6946}],"producer_aliases":[{"alias_id":"PA-SG-COMPILER-001","bidirectional_match_allowed":true,"contract_status":"CLOSED_DECISION_FIXTURE_PENDING","global_alias_allowed":false,"orchestration_producer_id":"Task_C_BO_S0_signal_bundle_writer","schema_writer_id":"Task_C_BO_S0_canonical_signal_compiler","scope":"STAGE1_PART2_SIGNAL_TRANSACTION_ONLY"}],"schema_version":"stage2_module_manifest.v1"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_00_inline_code_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_00_inline_code_receipt.json index 626a3493..85c75426 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_00_inline_code_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_00_inline_code_receipt.json @@ -1 +1 @@ -{"authoring":{"path":"Stage_2_S2_00_v.2.yml","sha256":"94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943","size_bytes":367573,"unique_key_parse":"PASS"},"authoring_rewritten":false,"build_kind":"OFFLINE_AUTHORING_PROJECTION","canonical_code":{"ast_status":"PASS","code_sha256":"e3f87725d5a6496189e7c411ef940dd8a7b3a9ff5b00535803bf98fa0cc4373e","code_size_bytes":283196,"compile_status":"PASS","encoding":"UTF-8","external_python_source_ref_count":0,"external_url_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","argparse","base64","binascii","collections","contextlib","dataclasses","hashlib","httpx","io","itertools","json","math","os","pathlib","re","shutil","stat","sys","tempfile","typing","unicodedata"],"placeholder_count":0,"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"deployment_projection":{"byte_identical_to_authoring":true,"canonical_task_semantics_sha256":"a970635aa19b4ebca03819e30de32bb69f33ca455f7ecd6257a45636565b4e95","path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml","sha256":"94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943","size_bytes":367573},"full_code_mirrors":[{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py","sha256":"e3f87725d5a6496189e7c411ef940dd8a7b3a9ff5b00535803bf98fa0cc4373e","size_bytes":283196},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt","sha256":"e3f87725d5a6496189e7c411ef940dd8a7b3a9ff5b00535803bf98fa0cc4373e","size_bytes":283196}],"parity_status":"PASS","schema_version":"stage2_s2_00_inline_code_receipt.v2","source_of_truth":"Stage_2_S2_00_v.2.yml","task_contract":{"agent":{"name":"Stage_2_S2_00_v2","version":"1.2.0"},"mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"stage":{"name":"S2_00","nexts":[],"prevs":[]},"task":{"code_sha256":"e3f87725d5a6496189e7c411ef940dd8a7b3a9ff5b00535803bf98fa0cc4373e","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_00_deterministic_ingress","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_00_deterministic_ingress"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_00_deterministic_ingress"]},"Task_S2_00_deterministic_ingress":{"nexts":["OUT"],"wait_until":["IN"]}}},"workflow_id":"S2_00"} +{"authoring":{"path":"Stage_2_S2_00_v.2.yml","sha256":"07bc9e235d211f3d4e6886bca2faeeb1f112d525fa29fe111bd7c50c42ff9849","size_bytes":382438,"unique_key_parse":"PASS"},"authoring_rewritten":false,"build_kind":"OFFLINE_AUTHORING_PROJECTION","canonical_code":{"ast_status":"PASS","code_sha256":"81e619b26560890f9a4066e4275f2f51e63910d7983ba453230d4dd6e90bfd6a","code_size_bytes":283196,"compile_status":"PASS","encoding":"UTF-8","external_python_source_ref_count":0,"external_url_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","argparse","base64","binascii","collections","contextlib","dataclasses","hashlib","httpx","io","itertools","json","math","os","pathlib","re","shutil","stat","sys","tempfile","typing","unicodedata"],"placeholder_count":0,"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/1/parameters/code"},"deployment_projection":{"byte_identical_to_authoring":true,"canonical_task_semantics_sha256":"0a0f84a21f30c607b1e0a63a037e43c373623a0c190cfdda7c7576e41c3c5bfc","path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml","sha256":"07bc9e235d211f3d4e6886bca2faeeb1f112d525fa29fe111bd7c50c42ff9849","size_bytes":382438},"full_code_mirrors":[{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.py","sha256":"16a57fbf3840d20edee8590a80b7b8161fe0b56637f271e850a5aa6be1e1f2d4","size_bytes":11062},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.txt","sha256":"16a57fbf3840d20edee8590a80b7b8161fe0b56637f271e850a5aa6be1e1f2d4","size_bytes":11062},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py","sha256":"81e619b26560890f9a4066e4275f2f51e63910d7983ba453230d4dd6e90bfd6a","size_bytes":283196},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt","sha256":"81e619b26560890f9a4066e4275f2f51e63910d7983ba453230d4dd6e90bfd6a","size_bytes":283196}],"parity_status":"PASS","prepare_code":{"ast_status":"PASS","code_sha256":"16a57fbf3840d20edee8590a80b7b8161fe0b56637f271e850a5aa6be1e1f2d4","code_size_bytes":11062,"compile_status":"PASS","encoding":"UTF-8","external_python_source_ref_count":0,"external_url_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","base64","hashlib","httpx","json","pathlib","re","sys","typing","unicodedata"],"placeholder_count":0,"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"schema_version":"stage2_s2_00_inline_code_receipt.v2","source_of_truth":"Stage_2_S2_00_v.2.yml","task_contract":{"agent":{"name":"Stage_2_S2_00_v2","version":"1.2.0"},"mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"prepare_task":{"code_sha256":"16a57fbf3840d20edee8590a80b7b8161fe0b56637f271e850a5aa6be1e1f2d4","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_00_prepare_request","tool_name":"run_code"},"stage":{"name":"S2_00","nexts":[],"prevs":[]},"task":{"code_sha256":"81e619b26560890f9a4066e4275f2f51e63910d7983ba453230d4dd6e90bfd6a","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_00_deterministic_ingress","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_00_prepare_request"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_00_deterministic_ingress"]},"Task_S2_00_deterministic_ingress":{"nexts":["OUT"],"wait_until":["Task_S2_00_prepare_request"]},"Task_S2_00_prepare_request":{"nexts":["Task_S2_00_deterministic_ingress"],"wait_until":["IN"]}}},"workflow_id":"S2_00"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_agent_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_agent_receipt.json index 8b4a26fa..985d00bd 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_agent_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_agent_receipt.json @@ -1 +1 @@ -{"agent_contract":{"agent_name":"Stage_2_S2_10","agent_version":"1.1.0","deterministic_task_count":0,"inline_common_prompt_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","inline_static_prompt_sha256":"894c30bedaa5f230aed117e81ef4cc06cac832928a1e29cd3ee8804cfd4dba1f","item_tokens":["{{item.selected_legal_context_json}}","{{item.cluster_case_payload_json}}"],"llm_task_count":1,"prompt_roles":["system","system","system","user"],"reduce_task_count":0,"stage_name":"S2_10","task_name":"Task_S2_10_resolve_cluster","tool_task_count":0},"authoring":{"path":"Stage_2_S2_10_v.1.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},"binding":{"path":"deployment/stage2_s2_10_llm_binding.yml","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},"child_release":{"path":"manifest/s2_10_release.json","release_digest":"8cfc30a40ad53b35fb44c56e3c53f86605f777622399a4b1dcd0b2082eb6e197","sha256":"cb49a4501116e46d935933b739b6679b11d961ff8e36abefea35dab6b25508fb"},"deployment":{"byte_parity":"PASS","path":"agent_scripts/Stage_2_S2_10.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},"external_admission_status":"PENDING","inline_prompt_receipt":{"path":"manifest/s2_10_inline_prompt_projection_receipt.json","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},"receipt_digest":"9bd92db101c0bf6f0c48764c71f5091e573dc65cce307ce3121b5d0271efc36c","receipt_status":"OFFLINE_AGENT_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","schema":{"path":"schemas/s2_10.schema.json","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},"schema_version":"stage2_s2_10_agent_receipt.v2","workflow":{"path":"workflows/S2_10_domain_relief_resolution_map.yml","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320}} +{"agent_contract":{"agent_name":"Stage_2_S2_10","agent_version":"1.1.0","deterministic_task_count":0,"inline_common_prompt_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","inline_static_prompt_sha256":"894c30bedaa5f230aed117e81ef4cc06cac832928a1e29cd3ee8804cfd4dba1f","item_tokens":["{{item.selected_legal_context_json}}","{{item.cluster_case_payload_json}}"],"llm_task_count":1,"prompt_roles":["system","system","system","user"],"reduce_task_count":0,"stage_name":"S2_10","task_name":"Task_S2_10_resolve_cluster","tool_task_count":0},"authoring":{"path":"Stage_2_S2_10_v.1.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},"binding":{"path":"deployment/stage2_s2_10_llm_binding.yml","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},"child_release":{"path":"manifest/s2_10_release.json","release_digest":"683fd83a4ffe3867c3c669f627c8ae7e719a6c9fe5f306267939e5d56b95e74a","sha256":"59cfa9d83497634e46f4f48ef691a9785a0b91228748fa65c9c23197e36fe105"},"deployment":{"byte_parity":"PASS","path":"agent_scripts/Stage_2_S2_10.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},"external_admission_status":"PENDING","inline_prompt_receipt":{"path":"manifest/s2_10_inline_prompt_projection_receipt.json","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},"receipt_digest":"eaa6900976362c532b312759d9ba8b8823eb79d7cbc0a6ed7d979ff905c7fd17","receipt_status":"OFFLINE_AGENT_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","schema":{"path":"schemas/s2_10.schema.json","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},"schema_version":"stage2_s2_10_agent_receipt.v2","workflow":{"path":"workflows/S2_10_domain_relief_resolution_map.yml","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320}} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_legal_review_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_legal_review_receipt.json index 05aebd31..9c82ec55 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_legal_review_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_legal_review_receipt.json @@ -1 +1 @@ -{"binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","finding_ids":[],"inline_prompt_projection_sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","receipt_digest":"18a29c299f5587993c17f5a40b1d2c60d03556e4b37306c23352d671c4dcbb7c","review_id":"S2_10-HYBRID-LEGAL-REVIEW-PENDING","review_scope_digest":"c8675e22ff50ba9599ab3ac3108f13718b412fc0de2425133f3f49981edf0735","reviewer_role":"KOREAN_ATTORNEY","s2_10_release_sha256":"cb49a4501116e46d935933b739b6679b11d961ff8e36abefea35dab6b25508fb","schema_version":"stage2_s2_10_legal_review_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null,"status":"PENDING_KOREAN_LAWYER_REVIEW"} +{"binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","finding_ids":[],"inline_prompt_projection_sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","receipt_digest":"f501b51861c6c5291ab3a2632cac239d362437afcada29274a57e33bc8bc1f00","review_id":"S2_10-HYBRID-LEGAL-REVIEW-PENDING","review_scope_digest":"59b98748330faaf05f894d340812f54434a547775c54403c5b3df4f7c7c15dc6","reviewer_role":"KOREAN_ATTORNEY","s2_10_release_sha256":"59cfa9d83497634e46f4f48ef691a9785a0b91228748fa65c9c23197e36fe105","schema_version":"stage2_s2_10_legal_review_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null,"status":"PENDING_KOREAN_LAWYER_REVIEW"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_model_benchmark_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_model_benchmark_receipt.json index b10e5b17..c3d08376 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_model_benchmark_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_model_benchmark_receipt.json @@ -1 +1 @@ -{"benchmark_id":"S2_10-HYBRID-MODEL-BENCHMARK-PENDING","binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","cache_telemetry_observed":null,"endpoint":"responses","latency_p95_ms":null,"model":"gpt-5.6-sol","observed_fixture_refs":[],"reasoning_effort":"xhigh","receipt_digest":"61f34770c1ebbc4c84c53ea925b07416b92f4baf4f1740294423eacbc17895ce","s2_10_release_sha256":"cb49a4501116e46d935933b739b6679b11d961ff8e36abefea35dab6b25508fb","schema_pass_rate":null,"schema_version":"stage2_s2_10_model_benchmark_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null,"status":"PENDING_MODEL_BENCHMARK","usage_telemetry_observed":null,"verbosity":"medium"} +{"benchmark_id":"S2_10-HYBRID-MODEL-BENCHMARK-PENDING","binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","cache_telemetry_observed":null,"endpoint":"responses","latency_p95_ms":null,"model":"gpt-5.6-sol","observed_fixture_refs":[],"reasoning_effort":"xhigh","receipt_digest":"8b1e3184937233eedb34f998d32a584d926407c87d3ce8300bcbc8a63498aa7e","s2_10_release_sha256":"59cfa9d83497634e46f4f48ef691a9785a0b91228748fa65c9c23197e36fe105","schema_pass_rate":null,"schema_version":"stage2_s2_10_model_benchmark_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null,"status":"PENDING_MODEL_BENCHMARK","usage_telemetry_observed":null,"verbosity":"medium"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_platform_adapter_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_platform_adapter_receipt.json index 935724ea..2805ab0e 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_platform_adapter_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_platform_adapter_receipt.json @@ -1 +1 @@ -{"adapter_contract_version":"S2_10_NATIVE_RESULT_ADAPTER_V2","binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","capabilities":[{"activation_binding_ref":null,"capability_id":"HOST_ATOMIC_SINGLE_FLIGHT_CAS_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"AGENTBACKEND_MAP_SOURCE_ITEMS_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"AGENTBACKEND_NO_REDUCE_RESULT_ADAPTER_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_STRICT_SCHEMA_AND_REF_VALIDATOR_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_DETERMINISTIC_ID_AND_IMMUTABLE_PERSIST_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_ITEM_RETRY_CONTROLLER_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"}],"overall_status":"PENDING_EXTERNAL_PLATFORM_BINDING","parent_stage2_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","receipt_digest":"3c3a005c2ff658a53c37631e82e5dc536e038bd357cacaaefbd37453b2a99245","receipt_id":"S2_10-HYBRID-PLATFORM-ADAPTER-PENDING","s2_10_release_sha256":"cb49a4501116e46d935933b739b6679b11d961ff8e36abefea35dab6b25508fb","schema_version":"stage2_s2_10_platform_adapter_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null} +{"adapter_contract_version":"S2_10_NATIVE_RESULT_ADAPTER_V2","binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","capabilities":[{"activation_binding_ref":null,"capability_id":"HOST_ATOMIC_SINGLE_FLIGHT_CAS_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"AGENTBACKEND_MAP_SOURCE_ITEMS_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"AGENTBACKEND_NO_REDUCE_RESULT_ADAPTER_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_STRICT_SCHEMA_AND_REF_VALIDATOR_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_DETERMINISTIC_ID_AND_IMMUTABLE_PERSIST_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"activation_binding_ref":null,"capability_id":"S2_10_ITEM_RETRY_CONTROLLER_V1","failure_reason_codes":["PENDING_EXTERNAL_PLATFORM_BINDING"],"handler_digest":null,"handler_version":null,"implementation_ref":null,"live_evidence_refs":[],"status":"PENDING_EXTERNAL_PLATFORM_BINDING"}],"overall_status":"PENDING_EXTERNAL_PLATFORM_BINDING","parent_stage2_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","receipt_digest":"e7f6d818b3ad2ab3093e1f9edb8ab2a06783d0e728b08bb91ddb6dc03755dd34","receipt_id":"S2_10-HYBRID-PLATFORM-ADAPTER-PENDING","s2_10_release_sha256":"59cfa9d83497634e46f4f48ef691a9785a0b91228748fa65c9c23197e36fe105","schema_version":"stage2_s2_10_platform_adapter_receipt.v2","signature_ref":null,"signed_at":null,"signed_by":null} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_release.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_release.json index 10d015a7..d7dc0c69 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_release.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_10_release.json @@ -1 +1 @@ -{"admission_status":{"legal_review":"PENDING_KOREAN_LAWYER_REVIEW","model_benchmark":"PENDING_MODEL_BENCHMARK","platform_adapter":"PENDING_EXTERNAL_PLATFORM_BINDING","production_execution":"BLOCKED","release_bound_canary":"SEPARATE_AUTHORIZATION_REQUIRED"},"authorization_status":"OFFLINE_VALIDATION_ONLY","constitution":{"deterministic_task_count":0,"dispatch_item_schema_version":"stage2_s2_10_dispatch_item.v2","llm_task_count":1,"prompt_contract_version":"S2_10_HYBRID_PROMPT_V1","raw_model_output_schema_version":"stage2_s2_10_model_output.v2","reduce_task_count":0,"runtime_python_asset_count":0,"tool_task_count":0},"external_admission_evidence":[{"path":"manifest/s2_10_platform_adapter_receipt.json","reason":"receipt attests this child release; reverse sealing would create a cycle","sealed_by_child_release":false},{"path":"manifest/s2_10_model_benchmark_receipt.json","reason":"generated only after a release-bound live canary","sealed_by_child_release":false},{"path":"manifest/s2_10_legal_review_receipt.json","reason":"generated only after release-bound Korean lawyer review","sealed_by_child_release":false}],"legacy_stage2_v0_v3_runtime_dependency_count":0,"model_binding":{"binding_status":"PENDING_MODEL_BENCHMARK","endpoint":"responses","model_id":"gpt-5.6-sol","provider":"openai","reasoning_effort":"xhigh","verbosity":"medium"},"parent_stage2_release_ref":{"declared_release_digest":"829be0e66d32a2bb0e07dca758faccfcfa7692333c1e116e631e11f7b4060815","declared_release_id":"STAGE2-CLEAN-DEV-DRAFT-S2_00-HYBRID-HANDOFF-2026-08-30","declared_release_status":"DRAFT_NOT_EXECUTABLE","path":"manifest/stage2_release.json","sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53"},"producer_contract":{"material":{"algorithm_id":"S2_10-PRODUCER-CONTRACT-PROJECTION-V1","claim_option_id_mint_algorithm_id":"S2_10-CLAIM-OPTION-ID-V1","local_relation_rewrite_algorithm_id":"S2_10-TWO-PASS-LOCAL-REF-REWRITE-V1","native_adapter_capability_projection_sha256":"3f08caa2ad872802267fc333069ea2436a9f23ec3d312241d8ed26e3fbbf0525","raw_model_output_schema_closure_algorithm_id":"S2_10-RAW-MODEL-SCHEMA-CLOSURE-BY-FULL-FILE-SHA256-V1","raw_model_output_schema_projection_sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","strict_validator_algorithm_id":"S2_10-OFFLINE-NATIVE-ADAPTER-ORACLE-V2","strict_validator_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b"},"s2_10_producer_contract_digest":"950da7b30a9799ad457118c2342854bf5cdc15990f382e1fd42c0e6cbc771dc2","self_referential_digest_fields_excluded":true,"whole_binding_hash_in_material":false},"prompt_binding":{"inline_common_prompt_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","inline_static_prompt_sha256":"894c30bedaa5f230aed117e81ef4cc06cac832928a1e29cd3ee8804cfd4dba1f","projection_receipt_sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","runtime_external_prompt_read_allowed":false},"release_class":"CHILD_OFFLINE_CONTRACT_RELEASE","release_digest":"8cfc30a40ad53b35fb44c56e3c53f86605f777622399a4b1dcd0b2082eb6e197","release_digest_contract":{"algorithm_id":"S2_10-CHILD-RELEASE-DIGEST-V2","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_RELEASE_DIGEST"},"release_id":"STAGE2-S2_10-HYBRID-OFFLINE-CONTRACT-2026-08-30","release_status":"OFFLINE_CONTRACT_COMPLETE_LIVE_ADMISSION_PENDING","schema_version":"stage2_s2_10_release.v2","sealed_asset_count":63,"sealed_assets":[{"path":"Stage_2_S2_10_v.1.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"path":"agent_scripts/Stage_2_S2_10.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"path":"workflows/S2_10_domain_relief_resolution_map.yml","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320},{"path":"schemas/s2_10.schema.json","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},{"path":"deployment/stage2_s2_10_llm_binding.yml","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","size_bytes":7287},{"path":"manifest/s2_10_inline_prompt_projection_receipt.json","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},{"path":"offline_build/build_s2_10_agent_projection.py","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"path":"offline_build/build_s2_10_agent_projection.txt","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"path":"offline_build/validate_s2_10_contract.py","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"path":"offline_build/validate_s2_10_contract.txt","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"path":"prompts/P00_system_and_safety_contract.md","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},{"path":"prompts/P10_legal_resolution_contract.md","sha256":"cafaab3991b8bd4ef3c95e55ce4c0649794c6eed9479d46d8c7758a4b823569b","size_bytes":8712},{"path":"registry/cache/prompt_cache_policy.yml","sha256":"32b638073b721a9f395d3476105e57236be4e076be81fd6e93f1475b29b93e2a","size_bytes":7527},{"path":"schemas/context.schema.json","sha256":"29073ffa847d74304228d61306503c0c3798da7db8b5717b1ad6d5b2da98aa92","size_bytes":39054},{"path":"schemas/review_status.schema.json","sha256":"dbf559cae183b9e9878a56ff9364ddfe68f7bf6ba1e00e595ec8876f2fc01d95","size_bytes":27241},{"path":"registry/authority/authority_registry.yml","sha256":"b4663610e18098cf650fbd5846f18dcbc96074b3012c68f03f67402509c7d142","size_bytes":1517},{"path":"manifest/authority_release.json","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967","size_bytes":1068},{"path":"law_values/general_law_values.yml","sha256":"45ad98e9e93090fbc5e5c7037f404bd86ff89b73a4aaf8c3449d226bd2aacd1c","size_bytes":843},{"path":"registry/substantive/E-01_juristic_act_validity.yml","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99","size_bytes":3808},{"path":"registry/substantive/E-02_contract_money_claim.yml","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824","size_bytes":3784},{"path":"registry/substantive/E-03_parties_liability_succession.yml","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c","size_bytes":3799},{"path":"registry/substantive/E-04_unjust_enrichment.yml","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7","size_bytes":3725},{"path":"registry/substantive/E-05_tort_general.yml","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a","size_bytes":3694},{"path":"registry/substantive/E-06_professional_liability.yml","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15","size_bytes":3724},{"path":"registry/substantive/E-07_construction_defect.yml","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9","size_bytes":3710},{"path":"registry/substantive/E-08_lease_deposit.yml","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db","size_bytes":3678},{"path":"registry/substantive/E-09_registry_transfer_claims.yml","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002","size_bytes":3800},{"path":"registry/substantive/E-10_secured_registry.yml","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba","size_bytes":3757},{"path":"registry/substantive/E-11_possession_vindication.yml","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf","size_bytes":3724},{"path":"registry/substantive/E-12_co_ownership_boundary.yml","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a","size_bytes":3712},{"path":"registry/substantive/E-13_creditor_preservation.yml","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45","size_bytes":3826},{"path":"registry/substantive/E-14_execution_linked_claims.yml","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7","size_bytes":3787},{"path":"registry/substantive/E-15_succession_family_property.yml","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766","size_bytes":3763},{"path":"registry/substantive/E-16_negotiable_instruments.yml","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194","size_bytes":3738},{"path":"registry/substantive/E-17_labor_wage_claims.yml","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea","size_bytes":3728},{"path":"registry/substantive/E-18_org_resolution_status.yml","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f","size_bytes":3763},{"path":"registry/substantive/E-19_insurance_claims.yml","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c","size_bytes":3685},{"path":"registry/substantive/E-20_ip_claims.yml","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1","size_bytes":3654},{"path":"registry/substantive/E-21_media_personality_rights.yml","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c","size_bytes":3803},{"path":"registry/substantive/EC-00_contract_general.yml","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8","size_bytes":3789},{"path":"profiles/crosscut/E-00_residual_unrouted.yml","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39","size_bytes":3752},{"path":"profiles/crosscut/X1_notice_lifecycle.yml","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef","size_bytes":3693},{"path":"profiles/crosscut/X2_asset_identity_lineage.yml","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad","size_bytes":3742},{"path":"profiles/crosscut/X3_procedure_standing_relief.yml","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df","size_bytes":3788},{"path":"profiles/crosscut/X4_response_admission_defense.yml","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e","size_bytes":3793},{"path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91","size_bytes":3762},{"path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e","size_bytes":3769},{"path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7","size_bytes":3797},{"path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f","size_bytes":3750},{"path":"profiles/special_law/SL-IP-COPYRIGHT.yml","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78","size_bytes":3728},{"path":"profiles/special_law/SL-IP-OTHER.yml","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8","size_bytes":3746},{"path":"profiles/special_law/SL-IP-PATENT.yml","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066","size_bytes":3709},{"path":"profiles/special_law/SL-LABOR.yml","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a","size_bytes":3694},{"path":"profiles/special_law/SL-MEDIA.yml","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c","size_bytes":3705},{"path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53","size_bytes":3737},{"path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7","size_bytes":3739},{"path":"profiles/special_law/SL-STATE_LIABILITY.yml","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3","size_bytes":3747},{"path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456","size_bytes":3835},{"path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191","size_bytes":3810},{"path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179","size_bytes":3828},{"path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee","size_bytes":3771},{"path":"profiles/overlays/ACTIO-MORTGAGE.yml","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d","size_bytes":3739},{"path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5","size_bytes":3816}]} +{"admission_status":{"legal_review":"PENDING_KOREAN_LAWYER_REVIEW","model_benchmark":"PENDING_MODEL_BENCHMARK","platform_adapter":"PENDING_EXTERNAL_PLATFORM_BINDING","production_execution":"BLOCKED","release_bound_canary":"SEPARATE_AUTHORIZATION_REQUIRED"},"authorization_status":"OFFLINE_VALIDATION_ONLY","constitution":{"deterministic_task_count":0,"dispatch_item_schema_version":"stage2_s2_10_dispatch_item.v2","llm_task_count":1,"prompt_contract_version":"S2_10_HYBRID_PROMPT_V1","raw_model_output_schema_version":"stage2_s2_10_model_output.v2","reduce_task_count":0,"runtime_python_asset_count":0,"tool_task_count":0},"external_admission_evidence":[{"path":"manifest/s2_10_platform_adapter_receipt.json","reason":"receipt attests this child release; reverse sealing would create a cycle","sealed_by_child_release":false},{"path":"manifest/s2_10_model_benchmark_receipt.json","reason":"generated only after a release-bound live canary","sealed_by_child_release":false},{"path":"manifest/s2_10_legal_review_receipt.json","reason":"generated only after release-bound Korean lawyer review","sealed_by_child_release":false}],"legacy_stage2_v0_v3_runtime_dependency_count":0,"model_binding":{"binding_status":"PENDING_MODEL_BENCHMARK","endpoint":"responses","model_id":"gpt-5.6-sol","provider":"openai","reasoning_effort":"xhigh","verbosity":"medium"},"parent_stage2_release_ref":{"declared_release_digest":"e533a83e51a6a71340b79f7caade858d67512b98642dd76eb3525cf065e58399","declared_release_id":"STAGE2-CLEAN-DEV-DRAFT-S2_00-HYBRID-HANDOFF-2026-08-30","declared_release_status":"DRAFT_NOT_EXECUTABLE","path":"manifest/stage2_release.json","sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590"},"producer_contract":{"material":{"algorithm_id":"S2_10-PRODUCER-CONTRACT-PROJECTION-V1","claim_option_id_mint_algorithm_id":"S2_10-CLAIM-OPTION-ID-V1","local_relation_rewrite_algorithm_id":"S2_10-TWO-PASS-LOCAL-REF-REWRITE-V1","native_adapter_capability_projection_sha256":"3f08caa2ad872802267fc333069ea2436a9f23ec3d312241d8ed26e3fbbf0525","raw_model_output_schema_closure_algorithm_id":"S2_10-RAW-MODEL-SCHEMA-CLOSURE-BY-FULL-FILE-SHA256-V1","raw_model_output_schema_projection_sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","strict_validator_algorithm_id":"S2_10-OFFLINE-NATIVE-ADAPTER-ORACLE-V2","strict_validator_sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b"},"s2_10_producer_contract_digest":"950da7b30a9799ad457118c2342854bf5cdc15990f382e1fd42c0e6cbc771dc2","self_referential_digest_fields_excluded":true,"whole_binding_hash_in_material":false},"prompt_binding":{"inline_common_prompt_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","inline_static_prompt_sha256":"894c30bedaa5f230aed117e81ef4cc06cac832928a1e29cd3ee8804cfd4dba1f","projection_receipt_sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","runtime_external_prompt_read_allowed":false},"release_class":"CHILD_OFFLINE_CONTRACT_RELEASE","release_digest":"683fd83a4ffe3867c3c669f627c8ae7e719a6c9fe5f306267939e5d56b95e74a","release_digest_contract":{"algorithm_id":"S2_10-CHILD-RELEASE-DIGEST-V2","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_RELEASE_DIGEST"},"release_id":"STAGE2-S2_10-HYBRID-OFFLINE-CONTRACT-2026-08-30","release_status":"OFFLINE_CONTRACT_COMPLETE_LIVE_ADMISSION_PENDING","schema_version":"stage2_s2_10_release.v2","sealed_asset_count":63,"sealed_assets":[{"path":"Stage_2_S2_10_v.1.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"path":"agent_scripts/Stage_2_S2_10.yml","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","size_bytes":30984},{"path":"workflows/S2_10_domain_relief_resolution_map.yml","sha256":"f0fba48f1760cf4e233d7d698fd19090f96ffb89cabe4b2e2cae9af7c616be0f","size_bytes":15320},{"path":"schemas/s2_10.schema.json","sha256":"5233afde9ddb3c5868b9101816e8b3830a90b1399e3e5e89d9d7c7bf5beacaee","size_bytes":82703},{"path":"deployment/stage2_s2_10_llm_binding.yml","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","size_bytes":7287},{"path":"manifest/s2_10_inline_prompt_projection_receipt.json","sha256":"b7fdef2ad05f251bdede9473d3b69c0f169ab7f4a059b393429ff76f739f703e","size_bytes":2659},{"path":"offline_build/build_s2_10_agent_projection.py","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"path":"offline_build/build_s2_10_agent_projection.txt","sha256":"efdde6d70c723e9386f2ba1828119af7e68f7956c29bd3ba05370242a70ab62d","size_bytes":68381},{"path":"offline_build/validate_s2_10_contract.py","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"path":"offline_build/validate_s2_10_contract.txt","sha256":"17996fb280435146ec0045a69c101c2d2088af27391cafc443a698eca70d5b0b","size_bytes":63811},{"path":"prompts/P00_system_and_safety_contract.md","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},{"path":"prompts/P10_legal_resolution_contract.md","sha256":"cafaab3991b8bd4ef3c95e55ce4c0649794c6eed9479d46d8c7758a4b823569b","size_bytes":8712},{"path":"registry/cache/prompt_cache_policy.yml","sha256":"32b638073b721a9f395d3476105e57236be4e076be81fd6e93f1475b29b93e2a","size_bytes":7527},{"path":"schemas/context.schema.json","sha256":"29073ffa847d74304228d61306503c0c3798da7db8b5717b1ad6d5b2da98aa92","size_bytes":39054},{"path":"schemas/review_status.schema.json","sha256":"dbf559cae183b9e9878a56ff9364ddfe68f7bf6ba1e00e595ec8876f2fc01d95","size_bytes":27241},{"path":"registry/authority/authority_registry.yml","sha256":"b4663610e18098cf650fbd5846f18dcbc96074b3012c68f03f67402509c7d142","size_bytes":1517},{"path":"manifest/authority_release.json","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967","size_bytes":1068},{"path":"law_values/general_law_values.yml","sha256":"45ad98e9e93090fbc5e5c7037f404bd86ff89b73a4aaf8c3449d226bd2aacd1c","size_bytes":843},{"path":"registry/substantive/E-01_juristic_act_validity.yml","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99","size_bytes":3808},{"path":"registry/substantive/E-02_contract_money_claim.yml","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824","size_bytes":3784},{"path":"registry/substantive/E-03_parties_liability_succession.yml","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c","size_bytes":3799},{"path":"registry/substantive/E-04_unjust_enrichment.yml","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7","size_bytes":3725},{"path":"registry/substantive/E-05_tort_general.yml","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a","size_bytes":3694},{"path":"registry/substantive/E-06_professional_liability.yml","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15","size_bytes":3724},{"path":"registry/substantive/E-07_construction_defect.yml","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9","size_bytes":3710},{"path":"registry/substantive/E-08_lease_deposit.yml","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db","size_bytes":3678},{"path":"registry/substantive/E-09_registry_transfer_claims.yml","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002","size_bytes":3800},{"path":"registry/substantive/E-10_secured_registry.yml","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba","size_bytes":3757},{"path":"registry/substantive/E-11_possession_vindication.yml","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf","size_bytes":3724},{"path":"registry/substantive/E-12_co_ownership_boundary.yml","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a","size_bytes":3712},{"path":"registry/substantive/E-13_creditor_preservation.yml","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45","size_bytes":3826},{"path":"registry/substantive/E-14_execution_linked_claims.yml","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7","size_bytes":3787},{"path":"registry/substantive/E-15_succession_family_property.yml","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766","size_bytes":3763},{"path":"registry/substantive/E-16_negotiable_instruments.yml","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194","size_bytes":3738},{"path":"registry/substantive/E-17_labor_wage_claims.yml","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea","size_bytes":3728},{"path":"registry/substantive/E-18_org_resolution_status.yml","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f","size_bytes":3763},{"path":"registry/substantive/E-19_insurance_claims.yml","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c","size_bytes":3685},{"path":"registry/substantive/E-20_ip_claims.yml","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1","size_bytes":3654},{"path":"registry/substantive/E-21_media_personality_rights.yml","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c","size_bytes":3803},{"path":"registry/substantive/EC-00_contract_general.yml","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8","size_bytes":3789},{"path":"profiles/crosscut/E-00_residual_unrouted.yml","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39","size_bytes":3752},{"path":"profiles/crosscut/X1_notice_lifecycle.yml","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef","size_bytes":3693},{"path":"profiles/crosscut/X2_asset_identity_lineage.yml","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad","size_bytes":3742},{"path":"profiles/crosscut/X3_procedure_standing_relief.yml","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df","size_bytes":3788},{"path":"profiles/crosscut/X4_response_admission_defense.yml","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e","size_bytes":3793},{"path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91","size_bytes":3762},{"path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e","size_bytes":3769},{"path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7","size_bytes":3797},{"path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f","size_bytes":3750},{"path":"profiles/special_law/SL-IP-COPYRIGHT.yml","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78","size_bytes":3728},{"path":"profiles/special_law/SL-IP-OTHER.yml","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8","size_bytes":3746},{"path":"profiles/special_law/SL-IP-PATENT.yml","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066","size_bytes":3709},{"path":"profiles/special_law/SL-LABOR.yml","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a","size_bytes":3694},{"path":"profiles/special_law/SL-MEDIA.yml","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c","size_bytes":3705},{"path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53","size_bytes":3737},{"path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7","size_bytes":3739},{"path":"profiles/special_law/SL-STATE_LIABILITY.yml","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3","size_bytes":3747},{"path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456","size_bytes":3835},{"path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191","size_bytes":3810},{"path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179","size_bytes":3828},{"path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee","size_bytes":3771},{"path":"profiles/overlays/ACTIO-MORTGAGE.yml","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d","size_bytes":3739},{"path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5","size_bytes":3816}]} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_20_inline_code_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_20_inline_code_receipt.json index 82ce37ac..1f3e459b 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_20_inline_code_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_20_inline_code_receipt.json @@ -1 +1 @@ -{"authoring":{"path":"Stage_2_S2_20.yml","sha256":"3c4e6a7404f5b6a6b2403824c3cd9e71db566d4f2865bd4de3e6fd9d07824bd6","size_bytes":254756},"canonical_code":{"ast_status":"PASS","code_sha256":"6f1f503378242cf64cf8f0838af2164ab1103bc7031c8a6873f4ee89be66f7fd","code_size_bytes":200269,"compile_status":"PASS","encoding":"UTF-8","endpoint_literals":["http://mcp-localdocs:8012/mcp","https://weaviate.eroomai.com/mcp"],"expected_parent_stage2_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","external_python_source_ref_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","base64","binascii","concurrent","contextlib","datetime","decimal","hashlib","httpx","io","itertools","json","pathlib","re","sys","typing","unicodedata"],"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"deployment_projection":{"path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml","sha256":"3c4e6a7404f5b6a6b2403824c3cd9e71db566d4f2865bd4de3e6fd9d07824bd6","size_bytes":254756},"full_code_mirrors":["Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py","Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt"],"parity_status":"PASS","schema_version":"stage2_s2_20_inline_code_receipt.v1","task_contract":{"agent":{"name":"Stage_2_S2_20","version":"1.0.0"},"authoring_rewritten":false,"canonical_task_semantics_sha256":"750bf364c9b73460349005590cbf65ae4c0235b5af0770937ccbbf669d159dd0","code_mirrors_byte_identical":true,"exactly_one_code_executor_run_code":true,"exactly_one_stage":true,"exactly_one_task":true,"expected_parent_stage2_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","internal_dag":"(C20||C21)->C25->C26->(C22||(C27->C28->C29))->C30->C35","mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"projection_byte_identical_to_authoring":true,"stage":{"name":"S2_20","nexts":[],"prevs":[],"skip_confirm":true},"task":{"code_sha256":"6f1f503378242cf64cf8f0838af2164ab1103bc7031c8a6873f4ee89be66f7fd","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_20_deterministic_relief_plan","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_20_deterministic_relief_plan"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_20_deterministic_relief_plan"]},"Task_S2_20_deterministic_relief_plan":{"nexts":["OUT"],"wait_until":["IN"]}}},"workflow_id":"S2_20"} +{"authoring":{"path":"Stage_2_S2_20.yml","sha256":"eb82f84df10c1eb4402e5e0f87fbe97a12e58aaa04f60c9535d66076300a5fdb","size_bytes":254756},"canonical_code":{"ast_status":"PASS","code_sha256":"91feb9e2ced624a2a4ea36e2b83bd17ed20bb059a42206fad01660800adeb515","code_size_bytes":200269,"compile_status":"PASS","encoding":"UTF-8","endpoint_literals":["http://mcp-localdocs:8012/mcp","https://weaviate.eroomai.com/mcp"],"expected_parent_stage2_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","external_python_source_ref_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","base64","binascii","concurrent","contextlib","datetime","decimal","hashlib","httpx","io","itertools","json","pathlib","re","sys","typing","unicodedata"],"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"deployment_projection":{"path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_20.yml","sha256":"eb82f84df10c1eb4402e5e0f87fbe97a12e58aaa04f60c9535d66076300a5fdb","size_bytes":254756},"full_code_mirrors":["Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py","Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt"],"parity_status":"PASS","schema_version":"stage2_s2_20_inline_code_receipt.v1","task_contract":{"agent":{"name":"Stage_2_S2_20","version":"1.0.0"},"authoring_rewritten":false,"canonical_task_semantics_sha256":"32f3abd5bf05c546f200284339abcaee222912b698bebe6ffdae44ac511a987c","code_mirrors_byte_identical":true,"exactly_one_code_executor_run_code":true,"exactly_one_stage":true,"exactly_one_task":true,"expected_parent_stage2_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","internal_dag":"(C20||C21)->C25->C26->(C22||(C27->C28->C29))->C30->C35","mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"projection_byte_identical_to_authoring":true,"stage":{"name":"S2_20","nexts":[],"prevs":[],"skip_confirm":true},"task":{"code_sha256":"91feb9e2ced624a2a4ea36e2b83bd17ed20bb059a42206fad01660800adeb515","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_20_deterministic_relief_plan","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_20_deterministic_relief_plan"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_20_deterministic_relief_plan"]},"Task_S2_20_deterministic_relief_plan":{"nexts":["OUT"],"wait_until":["IN"]}}},"workflow_id":"S2_20"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_agent_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_agent_receipt.json index cee2819c..1390920f 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_agent_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_agent_receipt.json @@ -1 +1 @@ -{"authoring_sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","binding_sha256":"7cf19e7dd8d3ad58251e20edc56e11fde3bffb3936997538eb09301da06189dc","byte_parity":"PASS","child_release_sha256":"e6dd6abe44b39de462ea01f5e78aa39c70bbf47e0b75e08d224615a297d2135f","deployment_sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","deterministic_helper_task_count":1,"llm_task_template_count":1,"receipt_digest":"fac154c1a47a050c1d8cac98a6df7abd92b0410e024c9cb26664dcef4006f13d","receipt_status":"OFFLINE_AGENT_PROJECTION_VERIFIED","reduce_task_count":0,"schema_version":"stage2_s2_30_agent_receipt.v1","task_template_count":2} +{"authoring_sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","binding_sha256":"2a479395e3c4d829500097c296089781ebce13a2bc18aaaea0f4bf42b5fc494a","byte_parity":"PASS","child_release_sha256":"5ca1bdb3499794a770e41612d20890b002ab0edaf7bdd916c211efefc96f10f4","deployment_sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","deterministic_helper_task_count":1,"llm_task_template_count":1,"receipt_digest":"5ba94db0f02a029eef813bd2f71bb84896cb1ced75e1a02431393c50cbecd1b5","receipt_status":"OFFLINE_AGENT_PROJECTION_VERIFIED","reduce_task_count":0,"schema_version":"stage2_s2_30_agent_receipt.v1","task_template_count":2} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_code_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_code_receipt.json index 63490f5e..3a6535a6 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_code_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_code_receipt.json @@ -1 +1 @@ -{"ast_policy_status":"PASS","authoring_agent_sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","compile_status":"PASS","inline_code_sha256":"1f7f3b842afbd3f1034f094d6341288effc9804a03920ada4bf8cfd512464e4c","inline_code_size_bytes":67777,"planner_mirror_paths":["runtime/s2_30_dispatch_planner.py","runtime/s2_30_dispatch_planner.txt"],"receipt_digest":"fe592796579be30899bde4006a0a3ba1d51b97b51a5b7049a3f67539158c71c9","receipt_status":"OFFLINE_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","runtime_external_python_import_count":0,"schema_version":"stage2_s2_30_inline_code_receipt.v1"} +{"ast_policy_status":"PASS","authoring_agent_sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","compile_status":"PASS","inline_code_sha256":"17e66a89befdeb3ac4d7901eda2dad57869db809baf5faf16434cd7a7adb067a","inline_code_size_bytes":67777,"planner_mirror_paths":["runtime/s2_30_dispatch_planner.py","runtime/s2_30_dispatch_planner.txt"],"receipt_digest":"dcc0a29b9753fb8afd1ace9a0da1a34f1bd14b880b253d7d590e1ad03fff40ff","receipt_status":"OFFLINE_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","runtime_external_python_import_count":0,"schema_version":"stage2_s2_30_inline_code_receipt.v1"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_prompt_projection_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_prompt_projection_receipt.json index ccba7041..f0afbd46 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_prompt_projection_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_inline_prompt_projection_receipt.json @@ -1 +1 @@ -{"authoring_agent":{"path":"Stage_2_S2_30.yml","sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","size_bytes":117060},"dynamic_item_tokens":["{{item.p32_common_authority_json}}","{{item.p31_rule_and_pack_json}}","{{item.s30_group_slice_json}}","{{item.compile_mode}}","{{item.s30_group_slice_sha256}}"],"inline_scalars":[{"parity":"PASS","raw_scalar_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","source":{"path":"prompts/P00_system_and_safety_contract.md","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},"wrapper":"stage_2_common_cache_prefix","yaml_pointer":"/Agent/Stages/0/tasks/1/prompts/0/content"},{"parity":"PASS","raw_scalar_sha256":"577efa2c3334298ec60188b9f0066f834e072dc99f785b3c6ab4d05a47fac18a","source":{"path":"prompts/P30_joint_drafting_contract.md","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},"wrapper":"s2_30_joint_drafting_static_prompt","yaml_pointer":"/Agent/Stages/0/tasks/1/prompts/1/content"}],"message_order":["INLINE_COMMON_SYSTEM","INLINE_S2_30_STATIC_SYSTEM","P32_COMMON_AUTHORITY_SYSTEM_DATA","P31_RULE_AND_PACK_SYSTEM_DATA","S30_GROUP_CASE_USER_DATA"],"receipt_digest":"13b89691392616f6f70b2cb1a92a24ee4d891480b56c8c1b41b5bdabe88bbad1","receipt_status":"OFFLINE_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","schema_version":"stage2_s2_30_inline_prompt_projection_receipt.v1"} +{"authoring_agent":{"path":"Stage_2_S2_30.yml","sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","size_bytes":117060},"dynamic_item_tokens":["{{item.p32_common_authority_json}}","{{item.p31_rule_and_pack_json}}","{{item.s30_group_slice_json}}","{{item.compile_mode}}","{{item.s30_group_slice_sha256}}"],"inline_scalars":[{"parity":"PASS","raw_scalar_sha256":"a90ac95f0b24ea938a16699f34ef7f17eb870edcbd8964ba4f6709e36e1bbcc0","source":{"path":"prompts/P00_system_and_safety_contract.md","sha256":"c82cfc0b61adb1af7759fd321f78bcf7bebf7e5d2fc3a9c01533a80736c6d80e","size_bytes":7304},"wrapper":"stage_2_common_cache_prefix","yaml_pointer":"/Agent/Stages/0/tasks/1/prompts/0/content"},{"parity":"PASS","raw_scalar_sha256":"577efa2c3334298ec60188b9f0066f834e072dc99f785b3c6ab4d05a47fac18a","source":{"path":"prompts/P30_joint_drafting_contract.md","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},"wrapper":"s2_30_joint_drafting_static_prompt","yaml_pointer":"/Agent/Stages/0/tasks/1/prompts/1/content"}],"message_order":["INLINE_COMMON_SYSTEM","INLINE_S2_30_STATIC_SYSTEM","P32_COMMON_AUTHORITY_SYSTEM_DATA","P31_RULE_AND_PACK_SYSTEM_DATA","S30_GROUP_CASE_USER_DATA"],"receipt_digest":"172d342643993049c83b928a8445bd4954d0e9449aeab91917dec8f7cd4b1e4b","receipt_status":"OFFLINE_PROJECTION_VERIFIED","runtime_admission_effect":"NONE","schema_version":"stage2_s2_30_inline_prompt_projection_receipt.v1"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_legal_review_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_legal_review_receipt.json index beb619d3..aee08778 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_legal_review_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_legal_review_receipt.json @@ -1 +1 @@ -{"binding_sha256":"7cf19e7dd8d3ad58251e20edc56e11fde3bffb3936997538eb09301da06189dc","child_release_sha256":"e6dd6abe44b39de462ea01f5e78aa39c70bbf47e0b75e08d224615a297d2135f","evidence":[],"live_execution_attested":false,"parent_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","receipt_digest":"6fc276d58d8613c0f7a2f4cb31dce0fc12c04e0239168a969f77e8a3b85437cb","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_legal_review_receipt.v1","status":"PENDING_KOREAN_LAWYER_REVIEW"} +{"binding_sha256":"2a479395e3c4d829500097c296089781ebce13a2bc18aaaea0f4bf42b5fc494a","child_release_sha256":"5ca1bdb3499794a770e41612d20890b002ab0edaf7bdd916c211efefc96f10f4","evidence":[],"live_execution_attested":false,"parent_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","receipt_digest":"0eb5248b6a0068e5b6c02473d251fb2efa1993106ec2eda84af5a123c17b7891","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_legal_review_receipt.v1","status":"PENDING_KOREAN_LAWYER_REVIEW"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_model_benchmark_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_model_benchmark_receipt.json index 17611d90..0d369f87 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_model_benchmark_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_model_benchmark_receipt.json @@ -1 +1 @@ -{"binding_sha256":"7cf19e7dd8d3ad58251e20edc56e11fde3bffb3936997538eb09301da06189dc","child_release_sha256":"e6dd6abe44b39de462ea01f5e78aa39c70bbf47e0b75e08d224615a297d2135f","evidence":[],"live_execution_attested":false,"parent_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","receipt_digest":"d8d231359c086ae13fec794d233ebf0ba5854c207da569923ed72d8c6ca90abc","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_model_benchmark_receipt.v1","status":"PENDING_MODEL_BENCHMARK"} +{"binding_sha256":"2a479395e3c4d829500097c296089781ebce13a2bc18aaaea0f4bf42b5fc494a","child_release_sha256":"5ca1bdb3499794a770e41612d20890b002ab0edaf7bdd916c211efefc96f10f4","evidence":[],"live_execution_attested":false,"parent_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","receipt_digest":"37dc500196b6282805fc8a70207a300a3a86832119b4e6595f52071fecce89f6","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_model_benchmark_receipt.v1","status":"PENDING_MODEL_BENCHMARK"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_platform_adapter_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_platform_adapter_receipt.json index 2d9688d5..f1d97397 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_platform_adapter_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_platform_adapter_receipt.json @@ -1 +1 @@ -{"binding_sha256":"7cf19e7dd8d3ad58251e20edc56e11fde3bffb3936997538eb09301da06189dc","capabilities":[{"capability_id":"HOST_ATOMIC_GROUP_DISPATCH_CAS_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"AGENTBACKEND_TASK_PROCEDURE_WILDCARD_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"AGENTBACKEND_WILDCARD_RESULT_ADAPTER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CONTEXT_MATERIALIZER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CACHE_OWNER_SEQUENCE_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_STRICT_SCHEMA_REF_PROVENANCE_VALIDATOR_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_DETERMINISTIC_ATOM_ID_TWO_PASS_PERSIST_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_GROUP_RETRY_CONTROLLER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_GROUP_BARRIER_COORDINATOR_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CANARY_AUTHORIZATION_SIGNATURE_VERIFY_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"}],"child_release_sha256":"e6dd6abe44b39de462ea01f5e78aa39c70bbf47e0b75e08d224615a297d2135f","evidence":[],"live_execution_attested":false,"overall_status":"PENDING_EXTERNAL_PLATFORM_BINDING","parent_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","receipt_digest":"31b81bdbef3bea6712c6ca2921af4e6b55e264f69b2ed341e1d83c770d3df1c5","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_platform_adapter_receipt.v1"} +{"binding_sha256":"2a479395e3c4d829500097c296089781ebce13a2bc18aaaea0f4bf42b5fc494a","capabilities":[{"capability_id":"HOST_ATOMIC_GROUP_DISPATCH_CAS_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"AGENTBACKEND_TASK_PROCEDURE_WILDCARD_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"AGENTBACKEND_WILDCARD_RESULT_ADAPTER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CONTEXT_MATERIALIZER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CACHE_OWNER_SEQUENCE_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_STRICT_SCHEMA_REF_PROVENANCE_VALIDATOR_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_DETERMINISTIC_ATOM_ID_TWO_PASS_PERSIST_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_GROUP_RETRY_CONTROLLER_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_GROUP_BARRIER_COORDINATOR_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"},{"capability_id":"S2_30_CANARY_AUTHORIZATION_SIGNATURE_VERIFY_V1","status":"PENDING_EXTERNAL_PLATFORM_BINDING"}],"child_release_sha256":"5ca1bdb3499794a770e41612d20890b002ab0edaf7bdd916c211efefc96f10f4","evidence":[],"live_execution_attested":false,"overall_status":"PENDING_EXTERNAL_PLATFORM_BINDING","parent_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","receipt_digest":"dbcbe59cd79d6a368b235fc4c038434cbe6acff500defdf41f5b5ac6630f2434","runtime_admission_effect":"BLOCK_PRODUCTION","schema_version":"stage2_s2_30_platform_adapter_receipt.v1"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_release.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_release.json index 3d28756f..4d9df1c8 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_release.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_30_release.json @@ -1 +1 @@ -{"admission_status":{"legal_review":"PENDING_KOREAN_LAWYER_REVIEW","model_benchmark":"PENDING_MODEL_BENCHMARK","platform_adapter":"PENDING_EXTERNAL_PLATFORM_BINDING","production_execution":"BLOCKED"},"authorization_status":"OFFLINE_VALIDATION_ONLY","external_admission_evidence":[{"path":"manifest/s2_30_platform_adapter_receipt.json","sealed_by_child_release":false},{"path":"manifest/s2_30_model_benchmark_receipt.json","sealed_by_child_release":false},{"path":"manifest/s2_30_legal_review_receipt.json","sealed_by_child_release":false}],"legacy_stage2_v0_v3_runtime_dependency_count":0,"parent_stage2_release_ref":{"path":"manifest/stage2_release.json","sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53"},"release_class":"CHILD_OFFLINE_CONTRACT_RELEASE","release_digest":"723a738d2fd6c181fa4afc1a59a50e06f62561934ff7671ab18b080e5847e4b4","release_id":"STAGE2-S2_30-OFFLINE-CONTRACT","release_status":"OFFLINE_CONTRACT_COMPLETE_LIVE_ADMISSION_PENDING","schema_version":"stage2_s2_30_release.v1","sealed_asset_count":39,"sealed_assets":[{"path":"Stage_2_S2_30.yml","sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","size_bytes":117060},{"path":"agent_scripts/Stage_2_S2_30.yml","sha256":"d0804526941207395c9b64a314b124ff8e919c6852e828d829dc45a9feb3ccdd","size_bytes":117060},{"path":"deployment/stage2_s2_30_llm_binding.yml","sha256":"7cf19e7dd8d3ad58251e20edc56e11fde3bffb3936997538eb09301da06189dc","size_bytes":2893},{"path":"manifest/s2_30_inline_code_receipt.json","sha256":"8d1618771cf1f72aa3c6a5a4544fe6b6e949ccc7ecfef56f166561971beee896","size_bytes":623},{"path":"manifest/s2_30_inline_prompt_projection_receipt.json","sha256":"1aa650d3c389ba27ce43e514295c7c2ce629583dc96220618fd97dea399d0757","size_bytes":1471},{"path":"offline_build/build_s2_30_agent_projection.py","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"path":"offline_build/build_s2_30_agent_projection.txt","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"path":"offline_build/validate_s2_30_contract.py","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"path":"offline_build/validate_s2_30_contract.txt","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"path":"prompts/P30_joint_drafting_contract.md","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},{"path":"runtime/s2_30_dispatch_planner.py","sha256":"1f7f3b842afbd3f1034f094d6341288effc9804a03920ada4bf8cfd512464e4c","size_bytes":67777},{"path":"runtime/s2_30_dispatch_planner.txt","sha256":"1f7f3b842afbd3f1034f094d6341288effc9804a03920ada4bf8cfd512464e4c","size_bytes":67777},{"path":"schemas/draft_atoms.schema.json","sha256":"5107b64f01ffb3633a829c10652747760a5035c9cc07227c546e3f543005eda9","size_bytes":68470},{"path":"tests/fixtures/s2_30/adverse_fact_worknote_policy.json","sha256":"5b8e9101385f8d65b0332c3be63cb9a22063920675cc86aee51e04da7820aef7","size_bytes":3444},{"path":"tests/fixtures/s2_30/cache_prefix_drift.json","sha256":"845b44cfeb1246f16cd3458965683247efc360b166b31133e3286be400325f98","size_bytes":2109},{"path":"tests/fixtures/s2_30/context_reference_envelope.json","sha256":"a1d6ba9752b9d4fb479dfaaa763174988f38d87890db9487db9de556d3eade60","size_bytes":4804},{"path":"tests/fixtures/s2_30/counter_performance_and_declaration.json","sha256":"cfa3a8439ca938b05768798dfee39a3cc1e4980d5550526c787843622516da90","size_bytes":3322},{"path":"tests/fixtures/s2_30/follower_batch_dispatch.json","sha256":"3dffaf9862e15f2fe906ca63abb3be61e49177fb58abb4c4a7a8b25db4e4493b","size_bytes":2832},{"path":"tests/fixtures/s2_30/invalid_forbidden_output.json","sha256":"a2308629fc09f75ab226b89374c78323f62a9dbe296aebdd83170a0cfb926e09","size_bytes":2741},{"path":"tests/fixtures/s2_30/invalid_preassembled_prompt_item.json","sha256":"6655402c669e5b40f2e7028a5c0c89571d8e1597dbdef567b4c9d8e2eed15a79","size_bytes":2204},{"path":"tests/fixtures/s2_30/invalid_reference_output.json","sha256":"eb2982a09f4948baadc27ae49c4f125426074333ea4a626e9c56ddc5c24ce273","size_bytes":2663},{"path":"tests/fixtures/s2_30/owner_singleton_dispatch.json","sha256":"38f9c364591fcdfe60d0dea9f69eb86b2f3b883929f6d60d06a7c35ff376fca6","size_bytes":8448},{"path":"tests/fixtures/s2_30/partial_write_publish_barrier.json","sha256":"0d878b946ebf810e8d0d8da74af33e56f35e164b04076a3867344b95d5f953eb","size_bytes":3352},{"path":"tests/fixtures/s2_30/persisted_handoff_chain.json","sha256":"54d6d781a60640744cba4b9c2f88a0013a6e58656c9c80a809e39fd4ba7c1097","size_bytes":2016},{"path":"tests/fixtures/s2_30/regression_manifest.json","sha256":"43e5b20ef4389da9c03b8062ce8bfacf2cd880d2efa2a1cbe1e901f4111f64ea","size_bytes":3584},{"path":"tests/fixtures/s2_30/rule_requirement_admission_gap.json","sha256":"27dfad63f3508c5d40521270707d84b2bc0c58f035f47d0cde1ae2abc54f9a15","size_bytes":4298},{"path":"tests/fixtures/s2_30/technical_failure.json","sha256":"bdcc6410e7515edc73d6b154d5b618b3ec34273ddc7269dc3e3ce55a6eb35fa6","size_bytes":2719},{"path":"tests/fixtures/s2_30/valid_joint_draft_output.json","sha256":"0135616c9375602693af8e12c3c16cf2031eaf3d9b74783bec9b5065846327e8","size_bytes":12982},{"path":"tests/s2_30/test_agent_contract.py","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"path":"tests/s2_30/test_agent_contract.txt","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"path":"tests/s2_30/test_dispatch_materialization.py","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"path":"tests/s2_30/test_dispatch_materialization.txt","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"path":"tests/s2_30/test_draft_atom_contract.py","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"path":"tests/s2_30/test_draft_atom_contract.txt","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"path":"tests/s2_30/test_prompt_cache_and_boundaries.py","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"path":"tests/s2_30/test_release_adapter_retry.py","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"path":"tests/s2_30/test_release_adapter_retry.txt","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"path":"workflows/S2_30_claim_group_draft_map.yml","sha256":"b266e7b7ae8939b087bfdb7b34fff8b9c6011c835560ab690991d856ced0cc15","size_bytes":15221}]} +{"admission_status":{"legal_review":"PENDING_KOREAN_LAWYER_REVIEW","model_benchmark":"PENDING_MODEL_BENCHMARK","platform_adapter":"PENDING_EXTERNAL_PLATFORM_BINDING","production_execution":"BLOCKED"},"authorization_status":"OFFLINE_VALIDATION_ONLY","external_admission_evidence":[{"path":"manifest/s2_30_platform_adapter_receipt.json","sealed_by_child_release":false},{"path":"manifest/s2_30_model_benchmark_receipt.json","sealed_by_child_release":false},{"path":"manifest/s2_30_legal_review_receipt.json","sealed_by_child_release":false}],"legacy_stage2_v0_v3_runtime_dependency_count":0,"parent_stage2_release_ref":{"path":"manifest/stage2_release.json","sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590"},"release_class":"CHILD_OFFLINE_CONTRACT_RELEASE","release_digest":"2aedd8bdedee152f0728979e1490659f525317ff881f98f65c9146311c10e175","release_id":"STAGE2-S2_30-OFFLINE-CONTRACT","release_status":"OFFLINE_CONTRACT_COMPLETE_LIVE_ADMISSION_PENDING","schema_version":"stage2_s2_30_release.v1","sealed_asset_count":39,"sealed_assets":[{"path":"Stage_2_S2_30.yml","sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","size_bytes":117060},{"path":"agent_scripts/Stage_2_S2_30.yml","sha256":"8ff81d9a9db6b80216bf453634b93881f1c2ef7220962f077e44f703fb1457c3","size_bytes":117060},{"path":"deployment/stage2_s2_30_llm_binding.yml","sha256":"2a479395e3c4d829500097c296089781ebce13a2bc18aaaea0f4bf42b5fc494a","size_bytes":2893},{"path":"manifest/s2_30_inline_code_receipt.json","sha256":"a5e4e3161fc16f3e44ec9ae2c05d2c4706eca02099d844520973f76475343998","size_bytes":623},{"path":"manifest/s2_30_inline_prompt_projection_receipt.json","sha256":"00b66f3495de5d1ff1e6e508eae2939cf862fdfc799c9cd01544a7979f769c42","size_bytes":1471},{"path":"offline_build/build_s2_30_agent_projection.py","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"path":"offline_build/build_s2_30_agent_projection.txt","sha256":"665b6f00bae567ea67e3758be047f594fedae2c22a5047b30009fcd5d2c495b2","size_bytes":56585},{"path":"offline_build/validate_s2_30_contract.py","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"path":"offline_build/validate_s2_30_contract.txt","sha256":"14e4eefb73d40d004c95017c82cdc23ac1c1c0a54ea34562dcf322f6364ae27a","size_bytes":104292},{"path":"prompts/P30_joint_drafting_contract.md","sha256":"5d790fccdacd1b7ce27e25cd52e4c301dbce24ba276def18bca608b5b16362aa","size_bytes":13681},{"path":"runtime/s2_30_dispatch_planner.py","sha256":"17e66a89befdeb3ac4d7901eda2dad57869db809baf5faf16434cd7a7adb067a","size_bytes":67777},{"path":"runtime/s2_30_dispatch_planner.txt","sha256":"17e66a89befdeb3ac4d7901eda2dad57869db809baf5faf16434cd7a7adb067a","size_bytes":67777},{"path":"schemas/draft_atoms.schema.json","sha256":"5107b64f01ffb3633a829c10652747760a5035c9cc07227c546e3f543005eda9","size_bytes":68470},{"path":"tests/fixtures/s2_30/adverse_fact_worknote_policy.json","sha256":"5b8e9101385f8d65b0332c3be63cb9a22063920675cc86aee51e04da7820aef7","size_bytes":3444},{"path":"tests/fixtures/s2_30/cache_prefix_drift.json","sha256":"845b44cfeb1246f16cd3458965683247efc360b166b31133e3286be400325f98","size_bytes":2109},{"path":"tests/fixtures/s2_30/context_reference_envelope.json","sha256":"a1d6ba9752b9d4fb479dfaaa763174988f38d87890db9487db9de556d3eade60","size_bytes":4804},{"path":"tests/fixtures/s2_30/counter_performance_and_declaration.json","sha256":"cfa3a8439ca938b05768798dfee39a3cc1e4980d5550526c787843622516da90","size_bytes":3322},{"path":"tests/fixtures/s2_30/follower_batch_dispatch.json","sha256":"3dffaf9862e15f2fe906ca63abb3be61e49177fb58abb4c4a7a8b25db4e4493b","size_bytes":2832},{"path":"tests/fixtures/s2_30/invalid_forbidden_output.json","sha256":"a2308629fc09f75ab226b89374c78323f62a9dbe296aebdd83170a0cfb926e09","size_bytes":2741},{"path":"tests/fixtures/s2_30/invalid_preassembled_prompt_item.json","sha256":"6655402c669e5b40f2e7028a5c0c89571d8e1597dbdef567b4c9d8e2eed15a79","size_bytes":2204},{"path":"tests/fixtures/s2_30/invalid_reference_output.json","sha256":"eb2982a09f4948baadc27ae49c4f125426074333ea4a626e9c56ddc5c24ce273","size_bytes":2663},{"path":"tests/fixtures/s2_30/owner_singleton_dispatch.json","sha256":"38f9c364591fcdfe60d0dea9f69eb86b2f3b883929f6d60d06a7c35ff376fca6","size_bytes":8448},{"path":"tests/fixtures/s2_30/partial_write_publish_barrier.json","sha256":"0d878b946ebf810e8d0d8da74af33e56f35e164b04076a3867344b95d5f953eb","size_bytes":3352},{"path":"tests/fixtures/s2_30/persisted_handoff_chain.json","sha256":"54d6d781a60640744cba4b9c2f88a0013a6e58656c9c80a809e39fd4ba7c1097","size_bytes":2016},{"path":"tests/fixtures/s2_30/regression_manifest.json","sha256":"43e5b20ef4389da9c03b8062ce8bfacf2cd880d2efa2a1cbe1e901f4111f64ea","size_bytes":3584},{"path":"tests/fixtures/s2_30/rule_requirement_admission_gap.json","sha256":"27dfad63f3508c5d40521270707d84b2bc0c58f035f47d0cde1ae2abc54f9a15","size_bytes":4298},{"path":"tests/fixtures/s2_30/technical_failure.json","sha256":"bdcc6410e7515edc73d6b154d5b618b3ec34273ddc7269dc3e3ce55a6eb35fa6","size_bytes":2719},{"path":"tests/fixtures/s2_30/valid_joint_draft_output.json","sha256":"0135616c9375602693af8e12c3c16cf2031eaf3d9b74783bec9b5065846327e8","size_bytes":12982},{"path":"tests/s2_30/test_agent_contract.py","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"path":"tests/s2_30/test_agent_contract.txt","sha256":"26a37b0b5fa6c4273ed7deff6b0429e3223869533fc2384f4c364fe88d554da5","size_bytes":12199},{"path":"tests/s2_30/test_dispatch_materialization.py","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"path":"tests/s2_30/test_dispatch_materialization.txt","sha256":"9d6ca17f012566b3d7423195ef19908694604a81059bfc10bd0c34dab1c24665","size_bytes":13911},{"path":"tests/s2_30/test_draft_atom_contract.py","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"path":"tests/s2_30/test_draft_atom_contract.txt","sha256":"cb1ecf7131921c37aa4a6dc31f9053f21526f153407b90d1efffd472b0d68923","size_bytes":10484},{"path":"tests/s2_30/test_prompt_cache_and_boundaries.py","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"path":"tests/s2_30/test_prompt_cache_and_boundaries.txt","sha256":"1b9b562418bc24be6db09dc1d35f71845033adbc693aeb41fbba07be16fa7c9d","size_bytes":6284},{"path":"tests/s2_30/test_release_adapter_retry.py","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"path":"tests/s2_30/test_release_adapter_retry.txt","sha256":"e5af75d54f236eb8ba99b194a06aa31f02fddd5c6aa9ff7385401905359b292c","size_bytes":18566},{"path":"workflows/S2_30_claim_group_draft_map.yml","sha256":"b266e7b7ae8939b087bfdb7b34fff8b9c6011c835560ab690991d856ced0cc15","size_bytes":15221}]} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_40_inline_code_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_40_inline_code_receipt.json index 69e8ab25..2682cd7e 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_40_inline_code_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/s2_40_inline_code_receipt.json @@ -1 +1 @@ -{"authoring":{"path":"Stage_2_S2_40.yml","sha256":"5cbe2ac9aa73d95a5fa4e6cf71d7d8f0ad83aa05536f573c13e42505ef5d46f7","size_bytes":249967,"unique_key_parse":"PASS"},"authoring_rewritten":false,"build_kind":"OFFLINE_AUTHORING_PROJECTION","canonical_code":{"ast_status":"PASS","code_sha256":"e521e1a65294a769cd6bf20edb159f8720c105b60cb769885aa416c8c763dcef","code_size_bytes":200946,"compile_status":"PASS","encoding":"UTF-8","expected_parent_stage2_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","external_python_source_ref_count":0,"external_url_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","base64","binascii","contextlib","datetime","hashlib","httpx","io","itertools","json","pathlib","re","sys","typing","unicodedata"],"placeholder_count":0,"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"deployment_projection":{"byte_identical_to_authoring":true,"canonical_task_semantics_sha256":"a8d6450b5a40308b3c2af5227fd3bc0c4f575dd8ea17b10b5bb7d6687ebc9d9e","path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml","sha256":"5cbe2ac9aa73d95a5fa4e6cf71d7d8f0ad83aa05536f573c13e42505ef5d46f7","size_bytes":249967},"expected_parent_stage2_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","full_code_mirrors":[{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py","sha256":"e521e1a65294a769cd6bf20edb159f8720c105b60cb769885aa416c8c763dcef","size_bytes":200946},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt","sha256":"e521e1a65294a769cd6bf20edb159f8720c105b60cb769885aa416c8c763dcef","size_bytes":200946}],"parity_status":"PASS","schema_version":"stage2_s2_40_inline_code_receipt.v1","source_of_truth":"Stage_2_S2_40.yml","task_contract":{"agent":{"name":"Stage_2_S2_40","version":"1.0.0"},"authoring_rewritten":false,"canonical_task_semantics_sha256":"a8d6450b5a40308b3c2af5227fd3bc0c4f575dd8ea17b10b5bb7d6687ebc9d9e","code_mirrors_byte_identical":true,"exactly_one_code_executor_run_code":true,"exactly_one_stage":true,"exactly_one_task":true,"mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"projection_byte_identical_to_authoring":true,"stage":{"name":"S2_40","nexts":[],"prevs":[]},"task":{"code_sha256":"e521e1a65294a769cd6bf20edb159f8720c105b60cb769885aa416c8c763dcef","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_40_deterministic_finalizer","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_40_deterministic_finalizer"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_40_deterministic_finalizer"]},"Task_S2_40_deterministic_finalizer":{"nexts":["OUT"],"wait_until":["IN"]}}},"workflow_id":"S2_40"} +{"authoring":{"path":"Stage_2_S2_40.yml","sha256":"a628f7fe944e21f77b9276cdb3d048189dcec958c7ed5abdcd9638b53a909a68","size_bytes":249967,"unique_key_parse":"PASS"},"authoring_rewritten":false,"build_kind":"OFFLINE_AUTHORING_PROJECTION","canonical_code":{"ast_status":"PASS","code_sha256":"12f6b83e1e6793ad871033c6e6b840fc1e31f9fb6695b1a15f0406978fe841f7","code_size_bytes":200946,"compile_status":"PASS","encoding":"UTF-8","expected_parent_stage2_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","external_python_source_ref_count":0,"external_url_count":0,"extraction_transform":"NONE","forbidden_dynamic_call_count":0,"forbidden_import_count":0,"imports":["__future__","base64","binascii","contextlib","datetime","hashlib","httpx","io","itertools","json","pathlib","re","sys","typing","unicodedata"],"placeholder_count":0,"plaintext_secret_count":0,"yaml_pointer":"/Agent/Stages/0/tasks/0/parameters/code"},"deployment_projection":{"byte_identical_to_authoring":true,"canonical_task_semantics_sha256":"de643093e087151fcc80b35be5518890ab64563f4c872260e4c56cbd00d09548","path":"Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml","sha256":"a628f7fe944e21f77b9276cdb3d048189dcec958c7ed5abdcd9638b53a909a68","size_bytes":249967},"expected_parent_stage2_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","full_code_mirrors":[{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py","sha256":"12f6b83e1e6793ad871033c6e6b840fc1e31f9fb6695b1a15f0406978fe841f7","size_bytes":200946},{"byte_identical_to_canonical_code":true,"path":"Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt","sha256":"12f6b83e1e6793ad871033c6e6b840fc1e31f9fb6695b1a15f0406978fe841f7","size_bytes":200946}],"parity_status":"PASS","schema_version":"stage2_s2_40_inline_code_receipt.v1","source_of_truth":"Stage_2_S2_40.yml","task_contract":{"agent":{"name":"Stage_2_S2_40","version":"1.0.0"},"authoring_rewritten":false,"canonical_task_semantics_sha256":"de643093e087151fcc80b35be5518890ab64563f4c872260e4c56cbd00d09548","code_mirrors_byte_identical":true,"exactly_one_code_executor_run_code":true,"exactly_one_stage":true,"exactly_one_task":true,"mcp_servers":{"code-executor":{"type":"streamable-http","url":"https://code-executor.mcp.eroomai.com/mcp"},"localdocs":{"type":"streamable-http","url":"http://mcp-localdocs:8012/mcp"}},"projection_byte_identical_to_authoring":true,"stage":{"name":"S2_40","nexts":[],"prevs":[]},"task":{"code_sha256":"12f6b83e1e6793ad871033c6e6b840fc1e31f9fb6695b1a15f0406978fe841f7","mcp":"code-executor","parameters":{"language":"python","network":"agent-network","requirements":"httpx==0.28.1","timeout":300},"task_name":"Task_S2_40_deterministic_finalizer","tool_name":"run_code"},"task_procedure":{"IN":{"nexts":["Task_S2_40_deterministic_finalizer"],"wait_until":[]},"OUT":{"nexts":[],"wait_until":["Task_S2_40_deterministic_finalizer"]},"Task_S2_40_deterministic_finalizer":{"nexts":["OUT"],"wait_until":["IN"]}}},"workflow_id":"S2_40"} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_deterministic_admission_receipt.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_deterministic_admission_receipt.json index 249b6a20..7b3ef64c 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_deterministic_admission_receipt.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_deterministic_admission_receipt.json @@ -1 +1 @@ -{"admission_status":"PENDING","backend_capability_receipt_sha256":"PENDING_SEQUENTIAL_BIND","embedded_task_admissions":[{"admission_scope":"CODE_EXECUTOR_HELPER_ONLY","binding_id":"S2-BINDING-S2_30-DISPATCH-PLANNER-V1","execution_unit_id":"S2_30::Task_S2_30_dispatch_planner","host_stage_id":"S2_30","inline_code_receipt_ref":{"asset_id":"RECEIPT-S2_30-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_30_inline_code_receipt.json","schema_id":"stage2_s2_30_inline_code_receipt.v1","sha256":"8d1618771cf1f72aa3c6a5a4544fe6b6e949ccc7ecfef56f166561971beee896"},"task_name":"Task_S2_30_dispatch_planner"}],"executor_binding_sha256":"a1062e9db242747c75a4362fb95eeba6c65f78ac647d4571ed774d2ee3af40f7","parent_release_sha256":"9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53","present_deterministic_stage_ids":["S2_00","S2_20","S2_40"],"schema_version":"stage2_deterministic_admission_receipt.v1","signature":"PENDING_EXTERNAL_SIGNATURE","signature_verification_status":"PENDING_EXTERNAL_SIGNATURE","signed_payload_sha256":"PENDING_SEQUENTIAL_BIND","stage_receipts":[{"asset_id":"RECEIPT-S2_00-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_00_inline_code_receipt.json","schema_id":"stage2_s2_00_inline_code_receipt.v2","sha256":"36af21949e5ef53a3d39df8ea9491c64da43abcc4f5e42e13db9bb391da843b8"},{"asset_id":"RECEIPT-S2_20-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_20_inline_code_receipt.json","schema_id":"stage2_s2_20_inline_code_receipt.v1","sha256":"65e29f10f065cdd77281aa47acaf341edb38b0595aab0aa9f04bbee3a4718608"},{"asset_id":"RECEIPT-S2_40-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_40_inline_code_receipt.json","schema_id":"stage2_s2_40_inline_code_receipt.v1","sha256":"9bd0cfaee8d9e78480ab80a2fa541414c7ad0565439fa0f4661701fcdfde6526"}]} +{"admission_status":"PENDING","backend_capability_receipt_sha256":"PENDING_SEQUENTIAL_BIND","embedded_task_admissions":[{"admission_scope":"CODE_EXECUTOR_HELPER_ONLY","binding_id":"S2-BINDING-S2_30-DISPATCH-PLANNER-V1","execution_unit_id":"S2_30::Task_S2_30_dispatch_planner","host_stage_id":"S2_30","inline_code_receipt_ref":{"asset_id":"RECEIPT-S2_30-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_30_inline_code_receipt.json","schema_id":"stage2_s2_30_inline_code_receipt.v1","sha256":"a5e4e3161fc16f3e44ec9ae2c05d2c4706eca02099d844520973f76475343998"},"task_name":"Task_S2_30_dispatch_planner"}],"executor_binding_sha256":"bc9aad7a5b817b5f4933bb74cd54782f3d777397a077f64fb9cd9ade55e4c40d","parent_release_sha256":"2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590","present_deterministic_stage_ids":["S2_00","S2_20","S2_40"],"schema_version":"stage2_deterministic_admission_receipt.v1","signature":"PENDING_EXTERNAL_SIGNATURE","signature_verification_status":"PENDING_EXTERNAL_SIGNATURE","signed_payload_sha256":"PENDING_SEQUENTIAL_BIND","stage_receipts":[{"asset_id":"RECEIPT-S2_00-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_00_inline_code_receipt.json","schema_id":"stage2_s2_00_inline_code_receipt.v2","sha256":"be044ab40ee86e7c3a1be6c421b2c5d36ee67fc2fd2870f59a3d9d911fef6c1a"},{"asset_id":"RECEIPT-S2_20-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_20_inline_code_receipt.json","schema_id":"stage2_s2_20_inline_code_receipt.v1","sha256":"64fd3711bd1128b6d29d3b8ff7a6af07228764da9604e0b5506562c5420e83e9"},{"asset_id":"RECEIPT-S2_40-INLINE-CODE","binding_status":"BOUND","path":"manifest/s2_40_inline_code_receipt.json","schema_id":"stage2_s2_40_inline_code_receipt.v1","sha256":"38fa1f5d8fc930ee3f7bbff7c73e1a52efc4995d14126ae035323ff74f1abf3d"}]} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_release.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_release.json index edb1a98c..0d7324bf 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_release.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/manifest/stage2_release.json @@ -1 +1 @@ -{"adapter_decisions":[{"adapter_id":"S2A-SIGNAL-ALL-V1","adapter_kind":"SIGNAL_ALL_EXPANSION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"file_conservation_equation":"semantic_file_rows + integrity_only_file_rows = Counter(signal_manifest.files[])","global_signal_id_uniqueness_assumed":false,"integrity_only_kinds":["compatibility_view"],"manifest_selector":"/downstream_read_sets/stage2","physical_path_rule":"U/signals/","record_conservation_equation":"used_record_occurrences + unused_record_occurrences + unmapped_record_occurrences = records_from_semantic_files","record_occurrence_key":["manifest_transaction_id","file_path","record_ordinal","signal_id"],"row_order":"PRESERVE_MANIFEST_ORDER","row_source":"/files","semantic_kinds":["canonical","domain_signal"],"sentinel":["ALL"]},"schema_ref":"schemas/ingress.schema.json#/$defs/all_expansion_contract"},{"adapter_id":"S2A-DUAL-SG01-V1","adapter_kind":"DUAL_SG01_PROJECTION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"comparison":"PARSED_CANONICAL_PROJECTION_EQUAL","payload_root":"/domain_activation_manifest","projection_json_pointers":["/schema_version","/signal_id","/status","/registry_version","/registry_index_sha256","/screening_sha256","/domain_entries","/active_domain_ids","/supporting_domain_ids","/monitor_domain_ids","/expected_runnable_domain_ids","/required_calculation_domains","/unrouted_material","/conservation_gate","/fail_open_policy","/review_items","/contract_guards"],"raw_hash_policy":"PRESERVE_AND_VERIFY_SEPARATELY","routing_path":"routing/domain_activation_manifest.json","set_semantics_json_pointers":["/active_domain_ids","/supporting_domain_ids","/monitor_domain_ids","/expected_runnable_domain_ids","/required_calculation_domains"],"signal_path":"signals/domain_activation_manifest.json"},"schema_ref":"schemas/ingress.schema.json#/$defs/dual_sg01_projection_contract"},{"adapter_id":"S2A-P1-HANDOFF-FLAT-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":false,"logical_input_id":"P1_REVIEW_HANDOFF","p1_digest_keys":["evidence_indexed_sha256","evidence_event_candidates_sha256","b1_gate_sha256","b2_gate_sha256","screening_sha256","activation_manifest_sha256","registry_index_sha256"],"review_items_json_pointer":"/review_items","schema_version":"stage1_part1_soft_gate_handoff.v1","seal_sources":["routing/domain_screening.json","routing/domain_activation_manifest.json","domains/_registry_index.json"],"source_stage":"P1","status_json_pointer":"/handoff_status","wrapper_json_pointer":""},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P2-HANDOFF-FLAT-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":false,"logical_input_id":"P2_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part2_review_handoff.v1","seal_sources":["BO.json","signals/signal_manifest.json"],"source_stage":"P2","status_json_pointer":"/status","wrapper_json_pointer":""},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P3-HANDOFF-WRAPPED-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":true,"logical_input_id":"P3_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part3_review_handoff.v1","seal_sources":["legal_effect_structures.json","validation_assets/routing/part3_receipt.json"],"source_stage":"P3","status_json_pointer":"/status","wrapper_json_pointer":"/stage1_part3_review_handoff"},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P4-HANDOFF-WRAPPED-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":true,"logical_input_id":"P4_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part4_review_handoff.v1","seal_sources":["Fact_Ledger_base.json","validation_assets/routing/part4_receipt.json","stage1_tmp/fact_ledger/fact_ledger_writer_report.json"],"source_stage":"P4","status_json_pointer":"/status","wrapper_json_pointer":"/stage1_part4_review_handoff"},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2-REVIEW-MAP-V1","adapter_kind":"REVIEW_NORMALIZATION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"aggregate_handoff_status_never_resolves_item":true,"handoff_status_mappings":[{"source_stage":"P1","source_value":"READY_NO_REVIEW","technical_disposition":"AVAILABLE"},{"source_stage":"P1","source_value":"READY_WITH_REVIEW","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P1","source_value":"BLOCKED","technical_disposition":"UNAVAILABLE"},{"source_stage":"P2","source_value":"PENDING_FINALIZE","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P2","source_value":"FINALIZED","technical_disposition":"AVAILABLE"},{"source_stage":"P3","source_value":"OPEN","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P3","source_value":"FINALIZED","technical_disposition":"AVAILABLE"},{"source_stage":"P4","source_value":"OPEN","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P4","source_value":"FINALIZED","technical_disposition":"AVAILABLE"}],"mappings":[{"mapping_id":"S2RM-001","normalized_partition":"SUPPORTED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"SUPPORTED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-002","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"CONDITIONAL","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-003","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"UNRESOLVED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-004","normalized_partition":"EXCLUDED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"EXCLUDED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-005","normalized_partition":"SUPPORTED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"observed","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-006","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"inferred","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-007","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"contested","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-008","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"missing_required","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-009","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"review","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-010","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"NO_SUPPORT","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-011","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"info","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-012","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"review","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-013","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"SOFT_WARNING","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-014","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"hard_warning","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-015","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"HARD_WARNING","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-016","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"block","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-017","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"BLOCK","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"}],"normalized_partitions":["SUPPORTED","CONDITIONAL","UNRESOLVED","EXCLUDED","UNMAPPED"],"resolution_inference_allowed":false,"unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},"schema_ref":"schemas/review_status.schema.json#/$defs/review_mapping_row"},{"adapter_id":"S2A-BO-V8-LIST-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"BO","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","required_item_fields":["BO_ID","id","BOType","ActionType","JuristicAct","Action","Reason","PriorAct","ReasonRefs","Legal_Keywords","core_field_base","amount","EvidenceTitles","Evidence","source_evidence_indexes","provenance","downstream_seed_refs","extensions"],"required_root_fields":[],"root_shape":"ARRAY","schema_contract_version":null},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-EVIDENCE-V3-ENVELOPE-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"EVIDENCE_INDEXED","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_B1_quality_gate_evidence_indexed","required_root_fields":["schema_contract_version","items"],"root_shape":"OBJECT_ENVELOPE","schema_contract_version":"evidence_indexed.v3"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-EVENTS-V1-ENVELOPE-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"EVIDENCE_EVENT_CANDIDATES","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_B2_quality_gate_event_candidates","required_root_fields":["schema_version","items"],"root_shape":"OBJECT_ENVELOPE","schema_contract_version":"evidence_event_candidates.v1"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-DOMAIN-CONFIG-V1","adapter_kind":"DOMAIN_CONFIG","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"accepted_schema_version":"stage1_domain_config.v1","depends_on_legal_dependency_allowed":false,"rebuttal_slot_synthesis_allowed":false,"required_slot_fields":["element_slots","opposing_fact_slots","defense_map","calculation_bindings","emits_signals"],"undeclared_slot_policy":"PRESERVE_AS_PROPOSED_NEW_SLOT_ISSUE"},"schema_ref":"schemas/ingress.schema.json#/$defs/domain_config_adapter_contract"},{"adapter_id":"S2A-DOMAIN-CONFIG-V2","adapter_kind":"DOMAIN_CONFIG","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"accepted_schema_version":"stage1_domain_config.v2","depends_on_legal_dependency_allowed":false,"rebuttal_slot_synthesis_allowed":false,"required_slot_fields":["element_slots","opposing_fact_slots","defense_map","calculation_bindings","emits_signals"],"undeclared_slot_policy":"PRESERVE_AS_PROPOSED_NEW_SLOT_ISSUE"},"schema_ref":"schemas/ingress.schema.json#/$defs/domain_config_adapter_contract"},{"adapter_id":"S2A-FACT-LEDGER-CURRENT-V8-V1","adapter_kind":"FACT_LEDGER","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"bo_source_bo_id_multiset_equality_required":true,"fact_id_pattern":"^F-[0-9]{3,}$","legacy_adapter_status":"DISABLED_NO_APPROVED_ADAPTER","producer_generation":"CURRENT_V8","required_row_fields":["fact_id","source_bo_id","domain_effects","calculation_requests"],"root_shape":"ARRAY"},"schema_ref":"schemas/ingress.schema.json#/$defs/fact_ledger_adapter_contract"},{"adapter_id":"PA-SG-COMPILER-001","adapter_kind":"PRODUCER_ALIAS","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"bidirectional_match_allowed":true,"global_alias_allowed":false,"orchestration_producer_id":"Task_C_BO_S0_signal_bundle_writer","schema_writer_id":"Task_C_BO_S0_canonical_signal_compiler","scope":"STAGE1_PART2_SIGNAL_TRANSACTION_ONLY"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_alias_contract"}],"authoring_root":"Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean","authorization_status":"DEV_VALIDATION_ONLY","bundle":{"active_profile_policy":"CASE_RUN_EXACT_RELEASE_SELECTED_SUBSET_ONLY","authority_release_status":"DEV_UNAVAILABLE","context_cohort_policy_id":"S2-CACHE-STRUCTURED-CONTEXT-HANDOFF-V2","downstream_hybrid_status":"OFFLINE_HYBRID_IMPLEMENTED_LIVE_ADMISSION_PENDING","executable":false,"handoff_contract_version":"S2_00_STRUCTURED_CONTEXT_HANDOFF_V2","mode":"STRUCTURAL_FIXTURE","reason_codes":["STRUCTURAL_FIXTURE_NOT_EXECUTABLE","AUTHORITY_RELEASE_UNAVAILABLE","S2_10_PLATFORM_MODEL_AND_LEGAL_ADMISSION_PENDING","DIRECT_MCP_LIVE_ADMISSION_PENDING"],"s2_10_agent_ref":{"asset_id":"AGENT-S2_10-HYBRID-OPAQUE","binding_status":"BOUND","path":"agent_scripts/Stage_2_S2_10.yml","schema_id":"liti_agent_yaml.v1","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272"},"s2_10_agent_sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","s2_10_llm_binding_ref":{"asset_id":"BINDING-S2_10-LLM-OPAQUE","binding_status":"BOUND","path":"deployment/stage2_s2_10_llm_binding.yml","schema_id":"stage2_s2_10_llm_binding.v2","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},"s2_10_llm_binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","selected_context_ordered_refs_sha256":"37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570","selected_context_refs":[]},"dependency_locks":{"downstream_availability":[{"asset_id":"CASE-TYPE-COVERAGE","binding_status":"BOUND","path":"manifest/case_type_coverage.json","schema_id":"stage2.case_type_coverage.v1","sha256":"34d6f758fc1486fa7330ede376e65b9448a6eaa971bd21472b0e4b7d9a5b8cba"},{"asset_id":"CORPUS-RELEASE","binding_status":"BOUND","path":"manifest/corpus_release.json","schema_id":"stage2.corpus_release.v1","sha256":"27d0c83e7a95342efdbe5be675b6d5b7d0ff8695eeec022ebc5aded3359fc981"}],"stage1":{"closure_scope":"REFERENCED_55_ONLY_NOT_FULL_STAGE1_RUNTIME_RELEASE","closure_snapshot_date":"2026-08-29","concrete_paths":[{"binding_status":"BOUND","lock_id":"S1-DEPLOY-001","path":"runtime_manifest.json","schema_id":"stage1_runtime_manifest.v1","sha256":"8964593a64a9b1bc90122054bb09eb3911827a06ed62dab0d6b7c745e7e18f54","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-002","path":"domains/_registry_index.json","schema_id":null,"sha256":"9f177ebf8860e20e05483967a2037f3baa09c2ac92c69ddeb260c04ca31ebf39","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-003","path":"signals/signal_registry.v2.json","schema_id":"signal_registry.v2","sha256":"4392b40da458102f8dd11b40b40ae3f694b7b5911849b050e2e4118c569e5ab0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-004","path":"domains/E-00/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"5919f7ea1d7be02666b0c48aa6a66445e6d454fc2fbb21d7fe5154b0a1e68f6f","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-005","path":"domains/E-01/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"b557e92cd1b093bf31792dbcf5b62cab8ad064a65c4421e79f141e06b4cc2192","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-006","path":"domains/E-02/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"be407c980c28226a15406f85b5861b04a4e19a13870513ac6626349fc05ac434","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-007","path":"domains/E-03/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7d3814f9b50cd5b33ef65a4eb778693552b3685bd369e765e9ac032734ebe23e","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-008","path":"domains/E-04/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"95a8c600cdce5a687f766788af0f763ee1b6a895e6ed80934afd28fe9a107e25","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-009","path":"domains/E-05/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e50541018f47aa27de2f8b13ec3fa52210cf8456a6feed8356af78c1f1da144a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-010","path":"domains/E-06/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"1e2bee36cb3c24dd37fc3beb3cf70236d531126c4f62ee97b5b42e55f4b0745c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-011","path":"domains/E-07/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"22ac562084b1ce231b7257d099c18b6a4619defa2fc42504d590e0bcc494c5f8","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-012","path":"domains/E-08/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"4d545306d42120e8552dd953d4336ef6de828ea827779944ba73acfda3d3a8bb","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-013","path":"domains/E-09/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7ef7340750094efeb372c397eb3134e21d62dda6988b1f6fa0a197b9963868e0","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-014","path":"domains/E-10/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e8d4f45fa76ea9e09333256dd4ea36cd3dd963bf60c04814a2cb8dc90d152f0a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-015","path":"domains/E-11/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"eb78d0188a0a2400307b1c34c8f8703c54cd86dd06b942c1709c44a8630a68e1","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-016","path":"domains/E-12/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"f336accdc6de10cdcc28c1190328054bca402fb77a2a9859d59fbaf5e84dd170","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-017","path":"domains/E-13/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e27e2e3855b5868a3ec12c7093b872434702f2e465b73c0bfc948b516aa0fc35","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-018","path":"domains/E-14/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"a273148cc17f07d90cda500fa5cb7df30c9cd253f7b86048cf4f63495d36a156","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-019","path":"domains/E-15/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7f37edddc101a08ed8a0e25f3a2c638e72571edc212ac91d96c1e33c51202a69","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-020","path":"domains/E-16/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"ae9af46ee31b6ef0dafedd35ccd7959a941d67d1a3dcc70e0b13647896873323","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-021","path":"domains/E-17/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"5c61f4486bdc968e4b30734b3c045404f0a711f47ea3abbe6c5c64652fb7f68c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-022","path":"domains/E-18/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"74ff76148d175929bdeeeced77e9a9922d29b51ad3d00ae6711c43c55717692c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-023","path":"domains/E-19/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"a8578f54a3fead3bbd35c62d7199b0f8aafb77f5d409a87236a55d2550fbfd37","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-024","path":"domains/E-20/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"29ee14cfe7789f004e6b6978d5360cf1bebe33bf88715df0cb47257993a11d00","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-025","path":"domains/E-21/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"4e1684a843d9e0c5af82f45332ad85abe94eda0c3ff0d578235d892aee39b908","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-026","path":"domains/EC-00/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"fe74de112b73289485dcead7e0fc7d270c794b3cf8a29ee00fab1eb64ba13861","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-027","path":"domains/X1/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"ad2fee7d206018f9a1f66e5fdf40dd67b686f6938099bad1ffc5d538db14ac57","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-028","path":"domains/X2/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"eba7d4671546bd66f1350d144ae0884f8beffb0dffdc147b45b9d5292676d46f","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-029","path":"domains/X3/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"8b67a638ae4a86aca3a2216974242b11ec39790162c9f366edfa91b02c3d270a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-030","path":"platform/schemas/client_goal_domain_profiles.schema.json","schema_id":null,"sha256":"ae2bfe0d754a09cbae16b2c15bf1518fc23f9e1bda8fa1f5f949606c8e42c010","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-031","path":"platform/schemas/domain_fanout_plan.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_fanout_plan.schema.json","sha256":"3b0948613a5996028b9c030a99f0b51d682f6035e019557756b1a15d43971113","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-032","path":"platform/schemas/domain_seed_output.schema.v3.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_seed_output.schema.v3.json","sha256":"992acf05dbccb34c65ead4e8c592f424e3b91672dc109cbd1bfa76a0a71a13c9","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-033","path":"platform/schemas/domain_slice.schema.v2.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_slice.schema.v2.json","sha256":"212a405088e7cf7ba2c65528a1c716938c946df7fe3bae3256b613051ed31aa3","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-034","path":"platform/schemas/fact_exception_pack.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_exception_pack.schema.json","sha256":"4eba7e51ed46a99e3704bc2333169749f4a16935de26a8c8027c1cac98ea58cf","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-035","path":"platform/schemas/fact_ledger_base.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_base.schema.json","sha256":"b3f0e79ecb4c2f720f3e07e89154aadbd2327e4129cc703569fb5635240d2fe8","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-036","path":"platform/schemas/fact_ledger_candidate_bundle.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_candidate_bundle.schema.json","sha256":"4e481504fb795b2be510680a8fa88124f5763a8124462f7870be4125ed9a7730","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-037","path":"platform/schemas/legal_effect_structures.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part3/legal_effect_structures.schema.json","sha256":"fc962e8ae39f9bede64ba017297eded6413689204a065e00c3b3bdca8f1854df","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-038","path":"platform/schemas/structure_seed_bundle.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part3/structure_seed_bundle.schema.json","sha256":"b7af9e422b6ac3876cffea39ec4f617eea76a631a57dfdfcd57d3785a83c667a","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-039","path":"signals/_common/evidence_slot_status.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/evidence_slot_status.schema.json","sha256":"292b03960b187cef668b8635a8d7539fde7c31f0c20d01af52c4f6ff8519d7b1","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-040","path":"signals/_common/signal_item.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/signal_item.schema.json","sha256":"de8695f98041c06cf50c0d8d2ebc31e7b3c518ca9d39a27da940438704c58bb1","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-041","path":"signals/schemas/domain_activation_manifest.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/domain_activation_manifest.schema.json","sha256":"013a6ebd230ebe46dda665af9f6c4448b267444b44e7b8f701f2fae80a2ee92a","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-042","path":"signals/schemas/procedural_posture_relief_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/procedural_posture_relief_signals.schema.json","sha256":"fefb4317ad63088919b61777c71fe75ee6aa507b9f599dcf455d2af63dfc5e0d","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-043","path":"signals/schemas/party_capacity_standing_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/party_capacity_standing_signals.schema.json","sha256":"66de89ac53964166f6caabd50cbc03eb82dede0acf702d5e6d825c1d82ef81d0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-044","path":"signals/schemas/governing_law_version_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/governing_law_version_signals.schema.json","sha256":"13a3f62f03356090d2cb24de2da0ba217928dfe8eb3c111d0f5e87c7df3119ee","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-045","path":"signals/schemas/legal_relation_lifecycle_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/legal_relation_lifecycle_signals.schema.json","sha256":"420613a5900c4360487b89b978efedde58f5ddc61644130e4b9e63ef8ab33d8b","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-046","path":"signals/schemas/timeline_notice_condition_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/timeline_notice_condition_signals.schema.json","sha256":"99c66208524155cea6bbd5e24fd26998cc9b653c89b24b569c793e36f1623d35","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-047","path":"signals/schemas/asset_right_state_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/asset_right_state_signals.schema.json","sha256":"fc34fbb3d33a284c3d57f3c278cbda8b3555ef26ee2f06b803fd2410ebce38b6","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-048","path":"signals/schemas/liability_causation_damage_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/liability_causation_damage_signals.schema.json","sha256":"34102cb8eeda80773eb62a5ee61e3d714bf90424ed5350dcac4b7bf873a72c5a","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-049","path":"signals/schemas/defense_exception_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/defense_exception_signals.schema.json","sha256":"010148c15e60e4d112b142f80b1723c06e34ba22b3edefae9e4371f2353b053e","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-050","path":"signals/schemas/evidence_proof_conflict_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/evidence_proof_conflict_signals.schema.json","sha256":"c419f568e28c06c629bc715aff7b0737b77e9c4871c91d4fae8f6ecf04196390","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-051","path":"signals/schemas/calculation_requirements.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/calculation_requirements.schema.json","sha256":"7fdb5ef0f50d7af22ac417abc4022cd238f5ab0dc942866420616729a9e3571f","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-052","path":"signals/schemas/remedy_enforcement_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/remedy_enforcement_signals.schema.json","sha256":"999e1969b983748f209e9b5239f7edd0ec43bc642d9ea8fd7edbf34f9ce653f3","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-053","path":"signals/schemas/legal_effect_routes.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/legal_effect_routes.schema.json","sha256":"c24cb740c370aa2477199a0225be8291164ef5c787601fd962a370c642cc3cc0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-054","path":"signals/schemas/domain_signal_envelope.schema.v2.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/domain_signal_envelope.schema.v2.json","sha256":"1483d6c5f98083f59172feff9b7c15b44d3ed789db5b6172d0de05f06e9d3fbc","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-055","path":"signals/schemas/signal_manifest.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/signal_manifest.schema.json","sha256":"5e72084780b82b29582c9ffcf48f3e4894d7c0b152e5ce8df394583c07dde681","source_manifest":"signals/signal_registry.v2.json"}],"contract_manifest_ref":{"mode":"CONDITIONAL_RELOCATION_ONLY","path":null,"sha256":null,"status":"NOT_REQUIRED_DEFAULT_PATHS"},"expected_concrete_path_count":55,"full_stage1_runtime_release_status":"STAGE1_NOT_RELEASE_READY"},"stage2_direct":[{"asset_id":"AGENT-S2_10-HYBRID-OPAQUE","binding_status":"BOUND","path":"agent_scripts/Stage_2_S2_10.yml","schema_id":"liti_agent_yaml.v1","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272"},{"asset_id":"BINDING-S2_10-LLM-OPAQUE","binding_status":"BOUND","path":"deployment/stage2_s2_10_llm_binding.yml","schema_id":"stage2_s2_10_llm_binding.v2","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},{"asset_id":"AUTHORITY-REGISTRY","binding_status":"BOUND","path":"registry/authority/authority_registry.yml","schema_id":"stage2.authority_registry.v1","sha256":"b4663610e18098cf650fbd5846f18dcbc96074b3012c68f03f67402509c7d142"},{"asset_id":"AUTHORITY-RELEASE","binding_status":"BOUND","path":"manifest/authority_release.json","schema_id":"stage2.authority_release.v1","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967"},{"asset_id":"PROFILE-EC-00_CONTRACT_GENERAL","binding_status":"BOUND","path":"registry/substantive/EC-00_contract_general.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8"},{"asset_id":"PROFILE-E-01_JURISTIC_ACT_VALIDITY","binding_status":"BOUND","path":"registry/substantive/E-01_juristic_act_validity.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99"},{"asset_id":"PROFILE-E-02_CONTRACT_MONEY_CLAIM","binding_status":"BOUND","path":"registry/substantive/E-02_contract_money_claim.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824"},{"asset_id":"PROFILE-E-03_PARTIES_LIABILITY_SUCCESSION","binding_status":"BOUND","path":"registry/substantive/E-03_parties_liability_succession.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c"},{"asset_id":"PROFILE-E-04_UNJUST_ENRICHMENT","binding_status":"BOUND","path":"registry/substantive/E-04_unjust_enrichment.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7"},{"asset_id":"PROFILE-E-05_TORT_GENERAL","binding_status":"BOUND","path":"registry/substantive/E-05_tort_general.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a"},{"asset_id":"PROFILE-E-06_PROFESSIONAL_LIABILITY","binding_status":"BOUND","path":"registry/substantive/E-06_professional_liability.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15"},{"asset_id":"PROFILE-E-07_CONSTRUCTION_DEFECT","binding_status":"BOUND","path":"registry/substantive/E-07_construction_defect.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9"},{"asset_id":"PROFILE-E-08_LEASE_DEPOSIT","binding_status":"BOUND","path":"registry/substantive/E-08_lease_deposit.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db"},{"asset_id":"PROFILE-E-09_REGISTRY_TRANSFER_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-09_registry_transfer_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002"},{"asset_id":"PROFILE-E-10_SECURED_REGISTRY","binding_status":"BOUND","path":"registry/substantive/E-10_secured_registry.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba"},{"asset_id":"PROFILE-E-11_POSSESSION_VINDICATION","binding_status":"BOUND","path":"registry/substantive/E-11_possession_vindication.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf"},{"asset_id":"PROFILE-E-12_CO_OWNERSHIP_BOUNDARY","binding_status":"BOUND","path":"registry/substantive/E-12_co_ownership_boundary.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a"},{"asset_id":"PROFILE-E-13_CREDITOR_PRESERVATION","binding_status":"BOUND","path":"registry/substantive/E-13_creditor_preservation.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45"},{"asset_id":"PROFILE-E-14_EXECUTION_LINKED_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-14_execution_linked_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7"},{"asset_id":"PROFILE-E-15_SUCCESSION_FAMILY_PROPERTY","binding_status":"BOUND","path":"registry/substantive/E-15_succession_family_property.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766"},{"asset_id":"PROFILE-E-16_NEGOTIABLE_INSTRUMENTS","binding_status":"BOUND","path":"registry/substantive/E-16_negotiable_instruments.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194"},{"asset_id":"PROFILE-E-17_LABOR_WAGE_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-17_labor_wage_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea"},{"asset_id":"PROFILE-E-18_ORG_RESOLUTION_STATUS","binding_status":"BOUND","path":"registry/substantive/E-18_org_resolution_status.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f"},{"asset_id":"PROFILE-E-19_INSURANCE_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-19_insurance_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c"},{"asset_id":"PROFILE-E-20_IP_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-20_ip_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1"},{"asset_id":"PROFILE-E-21_MEDIA_PERSONALITY_RIGHTS","binding_status":"BOUND","path":"registry/substantive/E-21_media_personality_rights.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c"},{"asset_id":"PROFILE-E-00_RESIDUAL_UNROUTED","binding_status":"BOUND","path":"profiles/crosscut/E-00_residual_unrouted.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39"},{"asset_id":"PROFILE-X1_NOTICE_LIFECYCLE","binding_status":"BOUND","path":"profiles/crosscut/X1_notice_lifecycle.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef"},{"asset_id":"PROFILE-X2_ASSET_IDENTITY_LINEAGE","binding_status":"BOUND","path":"profiles/crosscut/X2_asset_identity_lineage.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad"},{"asset_id":"PROFILE-X3_PROCEDURE_STANDING_RELIEF","binding_status":"BOUND","path":"profiles/crosscut/X3_procedure_standing_relief.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df"},{"asset_id":"PROFILE-X4_RESPONSE_ADMISSION_DEFENSE","binding_status":"BOUND","path":"profiles/crosscut/X4_response_admission_defense.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e"},{"asset_id":"PROFILE-SL-AUTO_MOTOR_VEHICLE","binding_status":"BOUND","path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91"},{"asset_id":"PROFILE-SL-INDUSTRIAL_ACCIDENT","binding_status":"BOUND","path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f"},{"asset_id":"PROFILE-SL-PRODUCT_LIABILITY","binding_status":"BOUND","path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53"},{"asset_id":"PROFILE-SL-RESIDENTIAL_LEASE","binding_status":"BOUND","path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7"},{"asset_id":"PROFILE-SL-COMMERCIAL_LEASE","binding_status":"BOUND","path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e"},{"asset_id":"PROFILE-SL-LABOR","binding_status":"BOUND","path":"profiles/special_law/SL-LABOR.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a"},{"asset_id":"PROFILE-SL-STATE_LIABILITY","binding_status":"BOUND","path":"profiles/special_law/SL-STATE_LIABILITY.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3"},{"asset_id":"PROFILE-SL-IP-PATENT","binding_status":"BOUND","path":"profiles/special_law/SL-IP-PATENT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066"},{"asset_id":"PROFILE-SL-IP-COPYRIGHT","binding_status":"BOUND","path":"profiles/special_law/SL-IP-COPYRIGHT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78"},{"asset_id":"PROFILE-SL-IP-OTHER","binding_status":"BOUND","path":"profiles/special_law/SL-IP-OTHER.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8"},{"asset_id":"PROFILE-SL-MEDIA","binding_status":"BOUND","path":"profiles/special_law/SL-MEDIA.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c"},{"asset_id":"PROFILE-SL-TRANSPORT_MARITIME","binding_status":"BOUND","path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456"},{"asset_id":"PROFILE-SL-CONSUMER_CONTRACT","binding_status":"BOUND","path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7"},{"asset_id":"PROFILE-ACTIO-MORTGAGE","binding_status":"BOUND","path":"profiles/overlays/ACTIO-MORTGAGE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d"},{"asset_id":"PROFILE-ACTIO-MORTGAGE-CREATION","binding_status":"BOUND","path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee"},{"asset_id":"PROFILE-ACTIO-ENCUMBERED-TRANSFER","binding_status":"BOUND","path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179"},{"asset_id":"PROFILE-ACTIO-PRESERVED-CLAIM-BUNDLE","binding_status":"BOUND","path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5"},{"asset_id":"PROFILE-ACTIO-DEFENSE-MAP","binding_status":"BOUND","path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191"}]},"executor_binding_ref":{"asset_id":"BINDING-S2_00-CODE-EXECUTOR","binding_status":"EXTERNAL_TRUST_ROOT_PENDING_LIVE_ADMISSION","path":"deployment/stage2_code_executor_binding.yml","schema_id":"stage2_code_executor_binding.v3"},"loader_binding_ref":{"asset_id":"BINDING-S2_00-LEGACY-REFERENCE","binding_status":"BOUND","path":"deployment/stage2_loader_binding.yml","schema_id":"stage2_loader_binding.reference.v1","sha256":"120313754c597541680a8dc7d9d59c6f8b2438c053553f030ef89171709dd23a"},"module_manifest_ref":{"asset_id":"MANIFEST-MODULE","binding_status":"BOUND","path":"manifest/module_manifest.json","schema_id":"stage2_module_manifest.v1","sha256":"2041e150b1e78c06cb7f24cde1eeb3eaa5ca172a4b740f6b20c1e6dda99bfd38"},"open_items":[{"open_id":"O-07","owner":"release_operator","required_evidence":"signed canary or production admission with current Stage 1 integrity closure","status":"OPEN_RELEASE_AUTHORIZATION"},{"open_id":"CEG-02-DIRECT-MCP-LIVE","owner":"AgentBackend_owner","required_evidence":"live code-executor.run_code outer result and inner single-JSON receipt with exact Agent/code/release binding","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-03-SECRET-INJECTION","owner":"AgentBackend_owner","required_evidence":"backend-injected or pre-registered Code Executor authentication with no plaintext credential in YAML or code","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-04-RUNTIME-IMAGE-PIN","owner":"Code_Executor_owner","required_evidence":"verified Python runtime image digest compatible with the bound httpx dependency","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-05-REQUEST-SIZE-TIMEOUT","owner":"Code_Executor_owner","required_evidence":"representative S2_00 Agent request accepted and completed within backend request-size and 300-second limits","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-06-BINARY-LOCALDOCS","owner":"localdocs_owner","required_evidence":"live read_binary_doc and write_binary_file byte-preservation receipt over the approved path set","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-07-ISOLATION-EGRESS","owner":"AgentBackend_security_owner","required_evidence":"workspace identity substitution and backend-enforced S2_00_LOCALDOCS_ONLY_V1 egress verification","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-08-BARRIER-ROUTE","owner":"Stage_2_integration_owner","required_evidence":"live status-last logical publish and exactly-one downstream route receipt","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"DEV-DETACHED-RELEASE-ENVELOPE","owner":"release_operator","required_evidence":"detached signed envelope admits the release and executor binding without a cross-file hash cycle","status":"OPEN_RELEASE_AUTHORIZATION"},{"open_id":"DOWNSTREAM-CASE-TYPE-REGISTRY","owner":"S2_20_case_type_registry_owner","required_evidence":"manifest/case_type_registry.yml exact path/hash and 137-row sign-off; not a direct S2_00 executable dependency","status":"PENDING_SEQUENTIAL_BIND"}],"release_class":"DEV_FIXTURE_RELEASE","release_digest":"829be0e66d32a2bb0e07dca758faccfcfa7692333c1e116e631e11f7b4060815","release_digest_contract":{"algorithm_id":"STAGE2-RELEASE-DIGEST-V1","array_order":"PRESERVE_DECLARED_ORDER","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","digest_algorithm":"sha256","digest_scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_RELEASE_DIGEST","encoding":"UTF-8","line_termination":"LF_ONE_TRAILING_NEWLINE","non_finite_numbers_allowed":false,"object_key_order":"SORT_CODEPOINT"},"release_evidence":[{"evidence_id":"DEV-DRAFT-UNSIGNED-001","input_digest":"c2c6949b6ddfa1b74a048c633413f3452967155bcaa1110bcd41cde3aeceba8b","release_class":"DEV_FIXTURE_RELEASE","scope":"INLINE_CODE_EXECUTOR_AND_STRUCTURED_HANDOFF_OFFLINE_HASH_BOUND_VALIDATION_ONLY","signature":"PENDING_SEQUENTIAL_BIND","signer_id":"UNSIGNED_DRAFT","status":"PENDING_SEQUENTIAL_BIND"}],"release_id":"STAGE2-CLEAN-DEV-DRAFT-S2_00-HYBRID-HANDOFF-2026-08-30","release_status":"DRAFT_NOT_EXECUTABLE","retry_policies":[{"backoff_seconds":[0,1,3],"max_attempts":3,"non_retryable_classes":["HASH","SCHEMA","PRODUCER","CONSERVATION","RUN_BINDING"],"retry_policy_id":"S2-RETRY-TRANSIENT-READ-V1","retryable_codes":["TRANSIENT_READ_ERROR","TRANSIENT_LOCK_ERROR"]}],"schema_version":"stage2_release.v2","signature":"PENDING_SEQUENTIAL_BIND","stage1_sources":[{"adapter_id":"S2A-EVIDENCE-V3-ENVELOPE-V1","logical_input_id":"evidence_indexed","path":"evidence_indexed.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B1_quality_gate_evidence_indexed","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","items"],"requirement_class":"EVIDENCE_EVENT_SCOPE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-EVENTS-V1-ENVELOPE-V1","logical_input_id":"evidence_event_candidates","path":"evidence_event_candidates.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B2_quality_gate_event_candidates","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","items"],"requirement_class":"EVIDENCE_EVENT_SCOPE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-CLIENT-GOAL-V8-V1","logical_input_id":"client_goal","path":"client_goal.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_A_client_goal","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["primary_goal","constraints","parties"],"requirement_class":"OPTIMIZATION_CONTEXT","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-DOMAIN-SCREENING-V1","logical_input_id":"domain_screening","path":"routing/domain_screening.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_A0_domain_screener_02","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["domain_screening"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-DUAL-SG01-V1","logical_input_id":"domain_activation_manifest","path":"routing/domain_activation_manifest.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_D0_domain_activation_gate","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["domain_activation_manifest"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/s5/domain_activation_manifest.schema.json","path":"signals/schemas/domain_activation_manifest.schema.json","sha256":"013a6ebd230ebe46dda665af9f6c4448b267444b44e7b8f701f2fae80a2ee92a"},"transaction_identity_pointer":null},{"adapter_id":"S2A-B1-GATE-V1","logical_input_id":"b1_evidence_indexed_gate","path":"quality_gates/B1_evidence_indexed_gate.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B12_gate_audit_finalizer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","gate_id","overall_severity","hard_gate_findings","review_findings","stage2_auto_progression_allowed"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-B2-GATE-V1","logical_input_id":"b2_event_candidates_gate","path":"quality_gates/B2_event_candidates_gate.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B12_gate_audit_finalizer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","gate_id","overall_severity","hard_gate_findings","review_findings","stage2_auto_progression_allowed"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-P1-HANDOFF-FLAT-V1","logical_input_id":"stage1_part1_soft_gate_handoff","path":"quality_gates/stage1_part1_soft_gate_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B2_SHA256_soft_gate_handoff_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","handoff_status","review_items","stage2_auto_progression_allowed","hard_gate_summary","review_item_conservation","digest_guard"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-BO-V8-LIST-V1","logical_input_id":"bo","path":"BO.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"IDENTITY_BACKBONE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-SIGNAL-ALL-V1","logical_input_id":"signal_manifest","path":"signals/signal_manifest.json","path_rule":null,"producer_alias_id":"PA-SG-COMPILER-001","producer_id":"Task_C_BO_S0_signal_bundle_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["files","downstream_read_sets"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/s5/signal_manifest.schema.json","path":"signals/schemas/signal_manifest.schema.json","sha256":"5e72084780b82b29582c9ffcf48f3e4894d7c0b152e5ce8df394583c07dde681"},"transaction_identity_pointer":"/transaction_id"},{"adapter_id":"S2A-P2-HANDOFF-FLAT-V1","logical_input_id":"stage1_part2_review_handoff","path":"quality_gates/stage1_part2_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","status","review_items"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-LES-CURRENT-V8-V1","logical_input_id":"legal_effect_structures","path":"legal_effect_structures.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_LE_L2_final_structure_index_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/part3/legal_effect_structures.schema.json","path":"platform/schemas/legal_effect_structures.schema.json","sha256":"fc962e8ae39f9bede64ba017297eded6413689204a065e00c3b3bdca8f1854df"},"transaction_identity_pointer":"/signal_manifest_transaction_id"},{"adapter_id":"S2A-P3-HANDOFF-WRAPPED-V1","logical_input_id":"stage1_part3_review_handoff","path":"quality_gates/stage1_part3_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_LE_L2_final_structure_index_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["stage1_part3_review_handoff"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-FACT-LEDGER-CURRENT-V8-V1","logical_input_id":"fact_ledger_base","path":"Fact_Ledger_base.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"IDENTITY_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_base.schema.json","path":"platform/schemas/fact_ledger_base.schema.json","sha256":"b3f0e79ecb4c2f720f3e07e89154aadbd2327e4129cc703569fb5635240d2fe8"},"transaction_identity_pointer":null},{"adapter_id":"S2A-FACT-LEDGER-WRITER-REPORT-V1","logical_input_id":"fact_ledger_writer_report","path":"stage1_tmp/fact_ledger/fact_ledger_writer_report.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-P4-HANDOFF-WRAPPED-V1","logical_input_id":"stage1_part4_review_handoff","path":"quality_gates/stage1_part4_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["stage1_part4_review_handoff"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-SIGNAL-ALL-V1","logical_input_id":"signal_payload_family","path":null,"path_rule":"signals/","producer_alias_id":"PA-SG-COMPILER-001","producer_id":"Task_C_BO_S0_signal_bundle_writer","raw_hash_source":"MANIFEST_ROW","required_keys":[],"requirement_class":"SIGNAL_PAYLOAD","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null}]} +{"adapter_decisions":[{"adapter_id":"S2A-SIGNAL-ALL-V1","adapter_kind":"SIGNAL_ALL_EXPANSION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"file_conservation_equation":"semantic_file_rows + integrity_only_file_rows = Counter(signal_manifest.files[])","global_signal_id_uniqueness_assumed":false,"integrity_only_kinds":["compatibility_view"],"manifest_selector":"/downstream_read_sets/stage2","physical_path_rule":"U/signals/","record_conservation_equation":"used_record_occurrences + unused_record_occurrences + unmapped_record_occurrences = records_from_semantic_files","record_occurrence_key":["manifest_transaction_id","file_path","record_ordinal","signal_id"],"row_order":"PRESERVE_MANIFEST_ORDER","row_source":"/files","semantic_kinds":["canonical","domain_signal"],"sentinel":["ALL"]},"schema_ref":"schemas/ingress.schema.json#/$defs/all_expansion_contract"},{"adapter_id":"S2A-DUAL-SG01-V1","adapter_kind":"DUAL_SG01_PROJECTION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"comparison":"PARSED_CANONICAL_PROJECTION_EQUAL","payload_root":"/domain_activation_manifest","projection_json_pointers":["/schema_version","/signal_id","/status","/registry_version","/registry_index_sha256","/screening_sha256","/domain_entries","/active_domain_ids","/supporting_domain_ids","/monitor_domain_ids","/expected_runnable_domain_ids","/required_calculation_domains","/unrouted_material","/conservation_gate","/fail_open_policy","/review_items","/contract_guards"],"raw_hash_policy":"PRESERVE_AND_VERIFY_SEPARATELY","routing_path":"routing/domain_activation_manifest.json","set_semantics_json_pointers":["/active_domain_ids","/supporting_domain_ids","/monitor_domain_ids","/expected_runnable_domain_ids","/required_calculation_domains"],"signal_path":"signals/domain_activation_manifest.json"},"schema_ref":"schemas/ingress.schema.json#/$defs/dual_sg01_projection_contract"},{"adapter_id":"S2A-P1-HANDOFF-FLAT-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":false,"logical_input_id":"P1_REVIEW_HANDOFF","p1_digest_keys":["evidence_indexed_sha256","evidence_event_candidates_sha256","b1_gate_sha256","b2_gate_sha256","screening_sha256","activation_manifest_sha256","registry_index_sha256"],"review_items_json_pointer":"/review_items","schema_version":"stage1_part1_soft_gate_handoff.v1","seal_sources":["routing/domain_screening.json","routing/domain_activation_manifest.json","domains/_registry_index.json"],"source_stage":"P1","status_json_pointer":"/handoff_status","wrapper_json_pointer":""},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P2-HANDOFF-FLAT-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":false,"logical_input_id":"P2_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part2_review_handoff.v1","seal_sources":["BO.json","signals/signal_manifest.json"],"source_stage":"P2","status_json_pointer":"/status","wrapper_json_pointer":""},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P3-HANDOFF-WRAPPED-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":true,"logical_input_id":"P3_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part3_review_handoff.v1","seal_sources":["legal_effect_structures.json","validation_assets/routing/part3_receipt.json"],"source_stage":"P3","status_json_pointer":"/status","wrapper_json_pointer":"/stage1_part3_review_handoff"},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2A-P4-HANDOFF-WRAPPED-V1","adapter_kind":"HANDOFF","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"count_field_required":true,"logical_input_id":"P4_REVIEW_HANDOFF","review_items_json_pointer":"/review_items","schema_version":"stage1_part4_review_handoff.v1","seal_sources":["Fact_Ledger_base.json","validation_assets/routing/part4_receipt.json","stage1_tmp/fact_ledger/fact_ledger_writer_report.json"],"source_stage":"P4","status_json_pointer":"/status","wrapper_json_pointer":"/stage1_part4_review_handoff"},"schema_ref":"schemas/ingress.schema.json#/$defs/handoff_adapter_contract"},{"adapter_id":"S2-REVIEW-MAP-V1","adapter_kind":"REVIEW_NORMALIZATION","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"aggregate_handoff_status_never_resolves_item":true,"handoff_status_mappings":[{"source_stage":"P1","source_value":"READY_NO_REVIEW","technical_disposition":"AVAILABLE"},{"source_stage":"P1","source_value":"READY_WITH_REVIEW","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P1","source_value":"BLOCKED","technical_disposition":"UNAVAILABLE"},{"source_stage":"P2","source_value":"PENDING_FINALIZE","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P2","source_value":"FINALIZED","technical_disposition":"AVAILABLE"},{"source_stage":"P3","source_value":"OPEN","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P3","source_value":"FINALIZED","technical_disposition":"AVAILABLE"},{"source_stage":"P4","source_value":"OPEN","technical_disposition":"AVAILABLE_WITH_ISSUES"},{"source_stage":"P4","source_value":"FINALIZED","technical_disposition":"AVAILABLE"}],"mappings":[{"mapping_id":"S2RM-001","normalized_partition":"SUPPORTED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"SUPPORTED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-002","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"CONDITIONAL","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-003","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"UNRESOLVED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-004","normalized_partition":"EXCLUDED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"EXCLUDED","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-005","normalized_partition":"SUPPORTED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"observed","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-006","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"inferred","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-007","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"contested","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-008","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"missing_required","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-009","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"review","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-010","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_STATUS","source_stage":"ANY","source_value":"NO_SUPPORT","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-011","normalized_partition":"CONDITIONAL","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"info","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-012","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"review","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-013","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"SOFT_WARNING","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-014","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"hard_warning","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-015","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"HARD_WARNING","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-016","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"block","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},{"mapping_id":"S2RM-017","normalized_partition":"UNRESOLVED","resolution_inference_allowed":false,"source_field_kind":"REVIEW_ITEM_SEVERITY","source_stage":"ANY","source_value":"BLOCK","unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"}],"normalized_partitions":["SUPPORTED","CONDITIONAL","UNRESOLVED","EXCLUDED","UNMAPPED"],"resolution_inference_allowed":false,"unknown_value_policy":"MAP_TO_UNMAPPED_AND_ISSUE"},"schema_ref":"schemas/review_status.schema.json#/$defs/review_mapping_row"},{"adapter_id":"S2A-BO-V8-LIST-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"BO","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","required_item_fields":["BO_ID","id","BOType","ActionType","JuristicAct","Action","Reason","PriorAct","ReasonRefs","Legal_Keywords","core_field_base","amount","EvidenceTitles","Evidence","source_evidence_indexes","provenance","downstream_seed_refs","extensions"],"required_root_fields":[],"root_shape":"ARRAY","schema_contract_version":null},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-EVIDENCE-V3-ENVELOPE-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"EVIDENCE_INDEXED","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_B1_quality_gate_evidence_indexed","required_root_fields":["schema_contract_version","items"],"root_shape":"OBJECT_ENVELOPE","schema_contract_version":"evidence_indexed.v3"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-EVENTS-V1-ENVELOPE-V1","adapter_kind":"PRODUCER_SHAPE","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"logical_input_id":"EVIDENCE_EVENT_CANDIDATES","open_source_fields_policy":"PRESERVE_UNMODELED_FIELDS_WITH_RAW_HASH","producer_id":"Task_B2_quality_gate_event_candidates","required_root_fields":["schema_version","items"],"root_shape":"OBJECT_ENVELOPE","schema_contract_version":"evidence_event_candidates.v1"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_shape_adapter"},{"adapter_id":"S2A-DOMAIN-CONFIG-V1","adapter_kind":"DOMAIN_CONFIG","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"accepted_schema_version":"stage1_domain_config.v1","depends_on_legal_dependency_allowed":false,"rebuttal_slot_synthesis_allowed":false,"required_slot_fields":["element_slots","opposing_fact_slots","defense_map","calculation_bindings","emits_signals"],"undeclared_slot_policy":"PRESERVE_AS_PROPOSED_NEW_SLOT_ISSUE"},"schema_ref":"schemas/ingress.schema.json#/$defs/domain_config_adapter_contract"},{"adapter_id":"S2A-DOMAIN-CONFIG-V2","adapter_kind":"DOMAIN_CONFIG","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"accepted_schema_version":"stage1_domain_config.v2","depends_on_legal_dependency_allowed":false,"rebuttal_slot_synthesis_allowed":false,"required_slot_fields":["element_slots","opposing_fact_slots","defense_map","calculation_bindings","emits_signals"],"undeclared_slot_policy":"PRESERVE_AS_PROPOSED_NEW_SLOT_ISSUE"},"schema_ref":"schemas/ingress.schema.json#/$defs/domain_config_adapter_contract"},{"adapter_id":"S2A-FACT-LEDGER-CURRENT-V8-V1","adapter_kind":"FACT_LEDGER","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"bo_source_bo_id_multiset_equality_required":true,"fact_id_pattern":"^F-[0-9]{3,}$","legacy_adapter_status":"DISABLED_NO_APPROVED_ADAPTER","producer_generation":"CURRENT_V8","required_row_fields":["fact_id","source_bo_id","domain_effects","calculation_requests"],"root_shape":"ARRAY"},"schema_ref":"schemas/ingress.schema.json#/$defs/fact_ledger_adapter_contract"},{"adapter_id":"PA-SG-COMPILER-001","adapter_kind":"PRODUCER_ALIAS","contract_status":"CLOSED_DECISION_FIXTURE_PENDING","decision":{"bidirectional_match_allowed":true,"global_alias_allowed":false,"orchestration_producer_id":"Task_C_BO_S0_signal_bundle_writer","schema_writer_id":"Task_C_BO_S0_canonical_signal_compiler","scope":"STAGE1_PART2_SIGNAL_TRANSACTION_ONLY"},"schema_ref":"schemas/ingress.schema.json#/$defs/producer_alias_contract"}],"authoring_root":"Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean","authorization_status":"DEV_VALIDATION_ONLY","bundle":{"active_profile_policy":"CASE_RUN_EXACT_RELEASE_SELECTED_SUBSET_ONLY","authority_release_status":"DEV_UNAVAILABLE","context_cohort_policy_id":"S2-CACHE-STRUCTURED-CONTEXT-HANDOFF-V2","downstream_hybrid_status":"OFFLINE_HYBRID_IMPLEMENTED_LIVE_ADMISSION_PENDING","executable":false,"handoff_contract_version":"S2_00_STRUCTURED_CONTEXT_HANDOFF_V2","mode":"STRUCTURAL_FIXTURE","reason_codes":["STRUCTURAL_FIXTURE_NOT_EXECUTABLE","AUTHORITY_RELEASE_UNAVAILABLE","S2_10_PLATFORM_MODEL_AND_LEGAL_ADMISSION_PENDING","DIRECT_MCP_LIVE_ADMISSION_PENDING"],"s2_10_agent_ref":{"asset_id":"AGENT-S2_10-HYBRID-OPAQUE","binding_status":"BOUND","path":"agent_scripts/Stage_2_S2_10.yml","schema_id":"liti_agent_yaml.v1","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272"},"s2_10_agent_sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272","s2_10_llm_binding_ref":{"asset_id":"BINDING-S2_10-LLM-OPAQUE","binding_status":"BOUND","path":"deployment/stage2_s2_10_llm_binding.yml","schema_id":"stage2_s2_10_llm_binding.v2","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},"s2_10_llm_binding_sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04","selected_context_ordered_refs_sha256":"37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570","selected_context_refs":[]},"dependency_locks":{"downstream_availability":[{"asset_id":"CASE-TYPE-COVERAGE","binding_status":"BOUND","path":"manifest/case_type_coverage.json","schema_id":"stage2.case_type_coverage.v1","sha256":"34d6f758fc1486fa7330ede376e65b9448a6eaa971bd21472b0e4b7d9a5b8cba"},{"asset_id":"CORPUS-RELEASE","binding_status":"BOUND","path":"manifest/corpus_release.json","schema_id":"stage2.corpus_release.v1","sha256":"27d0c83e7a95342efdbe5be675b6d5b7d0ff8695eeec022ebc5aded3359fc981"}],"stage1":{"closure_scope":"REFERENCED_55_ONLY_NOT_FULL_STAGE1_RUNTIME_RELEASE","closure_snapshot_date":"2026-08-29","concrete_paths":[{"binding_status":"BOUND","lock_id":"S1-DEPLOY-001","path":"runtime_manifest.json","schema_id":"stage1_runtime_manifest.v1","sha256":"8964593a64a9b1bc90122054bb09eb3911827a06ed62dab0d6b7c745e7e18f54","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-002","path":"domains/_registry_index.json","schema_id":null,"sha256":"9f177ebf8860e20e05483967a2037f3baa09c2ac92c69ddeb260c04ca31ebf39","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-003","path":"signals/signal_registry.v2.json","schema_id":"signal_registry.v2","sha256":"4392b40da458102f8dd11b40b40ae3f694b7b5911849b050e2e4118c569e5ab0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-004","path":"domains/E-00/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"5919f7ea1d7be02666b0c48aa6a66445e6d454fc2fbb21d7fe5154b0a1e68f6f","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-005","path":"domains/E-01/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"b557e92cd1b093bf31792dbcf5b62cab8ad064a65c4421e79f141e06b4cc2192","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-006","path":"domains/E-02/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"be407c980c28226a15406f85b5861b04a4e19a13870513ac6626349fc05ac434","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-007","path":"domains/E-03/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7d3814f9b50cd5b33ef65a4eb778693552b3685bd369e765e9ac032734ebe23e","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-008","path":"domains/E-04/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"95a8c600cdce5a687f766788af0f763ee1b6a895e6ed80934afd28fe9a107e25","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-009","path":"domains/E-05/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e50541018f47aa27de2f8b13ec3fa52210cf8456a6feed8356af78c1f1da144a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-010","path":"domains/E-06/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"1e2bee36cb3c24dd37fc3beb3cf70236d531126c4f62ee97b5b42e55f4b0745c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-011","path":"domains/E-07/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"22ac562084b1ce231b7257d099c18b6a4619defa2fc42504d590e0bcc494c5f8","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-012","path":"domains/E-08/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"4d545306d42120e8552dd953d4336ef6de828ea827779944ba73acfda3d3a8bb","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-013","path":"domains/E-09/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7ef7340750094efeb372c397eb3134e21d62dda6988b1f6fa0a197b9963868e0","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-014","path":"domains/E-10/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e8d4f45fa76ea9e09333256dd4ea36cd3dd963bf60c04814a2cb8dc90d152f0a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-015","path":"domains/E-11/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"eb78d0188a0a2400307b1c34c8f8703c54cd86dd06b942c1709c44a8630a68e1","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-016","path":"domains/E-12/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"f336accdc6de10cdcc28c1190328054bca402fb77a2a9859d59fbaf5e84dd170","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-017","path":"domains/E-13/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"e27e2e3855b5868a3ec12c7093b872434702f2e465b73c0bfc948b516aa0fc35","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-018","path":"domains/E-14/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"a273148cc17f07d90cda500fa5cb7df30c9cd253f7b86048cf4f63495d36a156","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-019","path":"domains/E-15/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"7f37edddc101a08ed8a0e25f3a2c638e72571edc212ac91d96c1e33c51202a69","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-020","path":"domains/E-16/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"ae9af46ee31b6ef0dafedd35ccd7959a941d67d1a3dcc70e0b13647896873323","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-021","path":"domains/E-17/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"5c61f4486bdc968e4b30734b3c045404f0a711f47ea3abbe6c5c64652fb7f68c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-022","path":"domains/E-18/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"74ff76148d175929bdeeeced77e9a9922d29b51ad3d00ae6711c43c55717692c","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-023","path":"domains/E-19/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"a8578f54a3fead3bbd35c62d7199b0f8aafb77f5d409a87236a55d2550fbfd37","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-024","path":"domains/E-20/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"29ee14cfe7789f004e6b6978d5360cf1bebe33bf88715df0cb47257993a11d00","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-025","path":"domains/E-21/domain_config.json","schema_id":"stage1_domain_config.v2","sha256":"4e1684a843d9e0c5af82f45332ad85abe94eda0c3ff0d578235d892aee39b908","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-026","path":"domains/EC-00/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"fe74de112b73289485dcead7e0fc7d270c794b3cf8a29ee00fab1eb64ba13861","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-027","path":"domains/X1/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"ad2fee7d206018f9a1f66e5fdf40dd67b686f6938099bad1ffc5d538db14ac57","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-028","path":"domains/X2/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"eba7d4671546bd66f1350d144ae0884f8beffb0dffdc147b45b9d5292676d46f","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-029","path":"domains/X3/domain_config.json","schema_id":"stage1_domain_config.v1","sha256":"8b67a638ae4a86aca3a2216974242b11ec39790162c9f366edfa91b02c3d270a","source_manifest":"domains/_registry_index.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-030","path":"platform/schemas/client_goal_domain_profiles.schema.json","schema_id":null,"sha256":"ae2bfe0d754a09cbae16b2c15bf1518fc23f9e1bda8fa1f5f949606c8e42c010","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-031","path":"platform/schemas/domain_fanout_plan.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_fanout_plan.schema.json","sha256":"3b0948613a5996028b9c030a99f0b51d682f6035e019557756b1a15d43971113","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-032","path":"platform/schemas/domain_seed_output.schema.v3.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_seed_output.schema.v3.json","sha256":"992acf05dbccb34c65ead4e8c592f424e3b91672dc109cbd1bfa76a0a71a13c9","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-033","path":"platform/schemas/domain_slice.schema.v2.json","schema_id":"https://schemas.liti-agent.local/stage1/s1/domain_slice.schema.v2.json","sha256":"212a405088e7cf7ba2c65528a1c716938c946df7fe3bae3256b613051ed31aa3","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-034","path":"platform/schemas/fact_exception_pack.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_exception_pack.schema.json","sha256":"4eba7e51ed46a99e3704bc2333169749f4a16935de26a8c8027c1cac98ea58cf","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-035","path":"platform/schemas/fact_ledger_base.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_base.schema.json","sha256":"b3f0e79ecb4c2f720f3e07e89154aadbd2327e4129cc703569fb5635240d2fe8","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-036","path":"platform/schemas/fact_ledger_candidate_bundle.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_candidate_bundle.schema.json","sha256":"4e481504fb795b2be510680a8fa88124f5763a8124462f7870be4125ed9a7730","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-037","path":"platform/schemas/legal_effect_structures.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part3/legal_effect_structures.schema.json","sha256":"fc962e8ae39f9bede64ba017297eded6413689204a065e00c3b3bdca8f1854df","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-038","path":"platform/schemas/structure_seed_bundle.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/part3/structure_seed_bundle.schema.json","sha256":"b7af9e422b6ac3876cffea39ec4f617eea76a631a57dfdfcd57d3785a83c667a","source_manifest":"runtime_manifest.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-039","path":"signals/_common/evidence_slot_status.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/evidence_slot_status.schema.json","sha256":"292b03960b187cef668b8635a8d7539fde7c31f0c20d01af52c4f6ff8519d7b1","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-040","path":"signals/_common/signal_item.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/signal_item.schema.json","sha256":"de8695f98041c06cf50c0d8d2ebc31e7b3c518ca9d39a27da940438704c58bb1","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-041","path":"signals/schemas/domain_activation_manifest.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/domain_activation_manifest.schema.json","sha256":"013a6ebd230ebe46dda665af9f6c4448b267444b44e7b8f701f2fae80a2ee92a","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-042","path":"signals/schemas/procedural_posture_relief_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/procedural_posture_relief_signals.schema.json","sha256":"fefb4317ad63088919b61777c71fe75ee6aa507b9f599dcf455d2af63dfc5e0d","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-043","path":"signals/schemas/party_capacity_standing_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/party_capacity_standing_signals.schema.json","sha256":"66de89ac53964166f6caabd50cbc03eb82dede0acf702d5e6d825c1d82ef81d0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-044","path":"signals/schemas/governing_law_version_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/governing_law_version_signals.schema.json","sha256":"13a3f62f03356090d2cb24de2da0ba217928dfe8eb3c111d0f5e87c7df3119ee","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-045","path":"signals/schemas/legal_relation_lifecycle_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/legal_relation_lifecycle_signals.schema.json","sha256":"420613a5900c4360487b89b978efedde58f5ddc61644130e4b9e63ef8ab33d8b","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-046","path":"signals/schemas/timeline_notice_condition_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/timeline_notice_condition_signals.schema.json","sha256":"99c66208524155cea6bbd5e24fd26998cc9b653c89b24b569c793e36f1623d35","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-047","path":"signals/schemas/asset_right_state_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/asset_right_state_signals.schema.json","sha256":"fc34fbb3d33a284c3d57f3c278cbda8b3555ef26ee2f06b803fd2410ebce38b6","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-048","path":"signals/schemas/liability_causation_damage_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/liability_causation_damage_signals.schema.json","sha256":"34102cb8eeda80773eb62a5ee61e3d714bf90424ed5350dcac4b7bf873a72c5a","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-049","path":"signals/schemas/defense_exception_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/defense_exception_signals.schema.json","sha256":"010148c15e60e4d112b142f80b1723c06e34ba22b3edefae9e4371f2353b053e","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-050","path":"signals/schemas/evidence_proof_conflict_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/evidence_proof_conflict_signals.schema.json","sha256":"c419f568e28c06c629bc715aff7b0737b77e9c4871c91d4fae8f6ecf04196390","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-051","path":"signals/schemas/calculation_requirements.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/calculation_requirements.schema.json","sha256":"7fdb5ef0f50d7af22ac417abc4022cd238f5ab0dc942866420616729a9e3571f","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-052","path":"signals/schemas/remedy_enforcement_signals.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/remedy_enforcement_signals.schema.json","sha256":"999e1969b983748f209e9b5239f7edd0ec43bc642d9ea8fd7edbf34f9ce653f3","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-053","path":"signals/schemas/legal_effect_routes.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/legal_effect_routes.schema.json","sha256":"c24cb740c370aa2477199a0225be8291164ef5c787601fd962a370c642cc3cc0","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-054","path":"signals/schemas/domain_signal_envelope.schema.v2.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/domain_signal_envelope.schema.v2.json","sha256":"1483d6c5f98083f59172feff9b7c15b44d3ed789db5b6172d0de05f06e9d3fbc","source_manifest":"signals/signal_registry.v2.json"},{"binding_status":"BOUND","lock_id":"S1-DEPLOY-055","path":"signals/schemas/signal_manifest.schema.json","schema_id":"https://schemas.liti-agent.local/stage1/s5/signal_manifest.schema.json","sha256":"5e72084780b82b29582c9ffcf48f3e4894d7c0b152e5ce8df394583c07dde681","source_manifest":"signals/signal_registry.v2.json"}],"contract_manifest_ref":{"mode":"CONDITIONAL_RELOCATION_ONLY","path":null,"sha256":null,"status":"NOT_REQUIRED_DEFAULT_PATHS"},"expected_concrete_path_count":55,"full_stage1_runtime_release_status":"STAGE1_NOT_RELEASE_READY"},"stage2_direct":[{"asset_id":"AGENT-S2_10-HYBRID-OPAQUE","binding_status":"BOUND","path":"agent_scripts/Stage_2_S2_10.yml","schema_id":"liti_agent_yaml.v1","sha256":"122fe890efb340ebbac299afe058bf9ad0ed87d4d0ccf2456393e9e5796ec272"},{"asset_id":"BINDING-S2_10-LLM-OPAQUE","binding_status":"BOUND","path":"deployment/stage2_s2_10_llm_binding.yml","schema_id":"stage2_s2_10_llm_binding.v2","sha256":"9b5d69f1316a0b9fba7b41097ee92142cf42485c8deb0be876d9e9329c317a04"},{"asset_id":"AUTHORITY-REGISTRY","binding_status":"BOUND","path":"registry/authority/authority_registry.yml","schema_id":"stage2.authority_registry.v1","sha256":"b4663610e18098cf650fbd5846f18dcbc96074b3012c68f03f67402509c7d142"},{"asset_id":"AUTHORITY-RELEASE","binding_status":"BOUND","path":"manifest/authority_release.json","schema_id":"stage2.authority_release.v1","sha256":"cc683958377eea44756de6e9c74fc925da66dd60cc84363f5bec36584f5b2967"},{"asset_id":"PROFILE-EC-00_CONTRACT_GENERAL","binding_status":"BOUND","path":"registry/substantive/EC-00_contract_general.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"a4f7abd9957b3a9e58d05dd559c3c869bf96fd88ea18968a363c6e606e3c0aa8"},{"asset_id":"PROFILE-E-01_JURISTIC_ACT_VALIDITY","binding_status":"BOUND","path":"registry/substantive/E-01_juristic_act_validity.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"0a0d2676f96be321a7bb974b8e4fb1981ab43773f271c99dc86a70cb17d27c99"},{"asset_id":"PROFILE-E-02_CONTRACT_MONEY_CLAIM","binding_status":"BOUND","path":"registry/substantive/E-02_contract_money_claim.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"08e252bccc718ccc44a258bc540afc2567e509239399f4017550df32bac97824"},{"asset_id":"PROFILE-E-03_PARTIES_LIABILITY_SUCCESSION","binding_status":"BOUND","path":"registry/substantive/E-03_parties_liability_succession.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"4e841d5f640b06a1b52060b82dda39605369cbe26d81655b7918673437e4519c"},{"asset_id":"PROFILE-E-04_UNJUST_ENRICHMENT","binding_status":"BOUND","path":"registry/substantive/E-04_unjust_enrichment.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"31a5966d4c14940e810f870bf4382f1be642f7716ebaaa35193ef32e9b9d95c7"},{"asset_id":"PROFILE-E-05_TORT_GENERAL","binding_status":"BOUND","path":"registry/substantive/E-05_tort_general.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fe6ea92fc10c4196e0ac83b990bf2606e24024030e7b0002fecdae9f8f50221a"},{"asset_id":"PROFILE-E-06_PROFESSIONAL_LIABILITY","binding_status":"BOUND","path":"registry/substantive/E-06_professional_liability.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"efa7a4f6cda90c04a06558a9d0e1efe13b25169d55d03e36d55d72fcdd096a15"},{"asset_id":"PROFILE-E-07_CONSTRUCTION_DEFECT","binding_status":"BOUND","path":"registry/substantive/E-07_construction_defect.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"78c76cb0485a4acf741109aee05f634f51c3a6904044c613080b21c3978a09f9"},{"asset_id":"PROFILE-E-08_LEASE_DEPOSIT","binding_status":"BOUND","path":"registry/substantive/E-08_lease_deposit.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"dbe1886671edff49b8b0251eed567d1b3e4e5d748456434262286ca7acf990db"},{"asset_id":"PROFILE-E-09_REGISTRY_TRANSFER_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-09_registry_transfer_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d18946322a8cb528146ac0aa0a2880c41ac2056671fd237b928341ceb8561002"},{"asset_id":"PROFILE-E-10_SECURED_REGISTRY","binding_status":"BOUND","path":"registry/substantive/E-10_secured_registry.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5819c26ec8478e12a12e340c93a9d23cc410833e1192c2315a1986c9d48a1eba"},{"asset_id":"PROFILE-E-11_POSSESSION_VINDICATION","binding_status":"BOUND","path":"registry/substantive/E-11_possession_vindication.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5e6d6460be4ec0f2ba0096305b9ae39f5f430d107337d0d7e07aac1a9d599aaf"},{"asset_id":"PROFILE-E-12_CO_OWNERSHIP_BOUNDARY","binding_status":"BOUND","path":"registry/substantive/E-12_co_ownership_boundary.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"62cfbf6a6c5c5edc8b912e348be1c4d4f7dd4c20c722e57e5554058f0caafb4a"},{"asset_id":"PROFILE-E-13_CREDITOR_PRESERVATION","binding_status":"BOUND","path":"registry/substantive/E-13_creditor_preservation.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"c60e6d67c7e3985d1f6ce44027726282f931934e3e66b44f06ccd26845ca2f45"},{"asset_id":"PROFILE-E-14_EXECUTION_LINKED_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-14_execution_linked_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"45d4b3ab46e1c8834c3b3eec72a28d05e39cb78a9ec2c2de07b5e55e81aeebd7"},{"asset_id":"PROFILE-E-15_SUCCESSION_FAMILY_PROPERTY","binding_status":"BOUND","path":"registry/substantive/E-15_succession_family_property.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"f691b67295ad8e634b34519cf71156caf6eaf73cef54577615ab79462f8aa766"},{"asset_id":"PROFILE-E-16_NEGOTIABLE_INSTRUMENTS","binding_status":"BOUND","path":"registry/substantive/E-16_negotiable_instruments.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7720d83b64e7a44720788f6ff3c7cc8ceaf5195377a1e61b52de2144989a1194"},{"asset_id":"PROFILE-E-17_LABOR_WAGE_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-17_labor_wage_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"168ce5e41104937cf7ab946944f060b82cfe16066425897f07bb9e837b8689ea"},{"asset_id":"PROFILE-E-18_ORG_RESOLUTION_STATUS","binding_status":"BOUND","path":"registry/substantive/E-18_org_resolution_status.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"59cf689f886dfaf4ad00dbe6142f5b11c37d0062660f7467aa43427462aa075f"},{"asset_id":"PROFILE-E-19_INSURANCE_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-19_insurance_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"0fb4793446c155e7a0b4469c9b8c1be1323112eef55ca4c495307c1af56e754c"},{"asset_id":"PROFILE-E-20_IP_CLAIMS","binding_status":"BOUND","path":"registry/substantive/E-20_ip_claims.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fe07f20d149a2c4deac2e46de299cd78f0bf829f58c615a86c45f542d30804e1"},{"asset_id":"PROFILE-E-21_MEDIA_PERSONALITY_RIGHTS","binding_status":"BOUND","path":"registry/substantive/E-21_media_personality_rights.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"951260bbe8ef116d682f49f3679106c7144ca68f8078f5c10b3459667c1f5b2c"},{"asset_id":"PROFILE-E-00_RESIDUAL_UNROUTED","binding_status":"BOUND","path":"profiles/crosscut/E-00_residual_unrouted.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"639e507147a6132f9e41ccd0b00d1b5450d6a9629991629b173d5bcaf5b6df39"},{"asset_id":"PROFILE-X1_NOTICE_LIFECYCLE","binding_status":"BOUND","path":"profiles/crosscut/X1_notice_lifecycle.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"9af8b5b5f3a8196a10308d1ee34e0788d9adeac7a99e142e449490d14316faef"},{"asset_id":"PROFILE-X2_ASSET_IDENTITY_LINEAGE","binding_status":"BOUND","path":"profiles/crosscut/X2_asset_identity_lineage.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6c1e437944b3a62b60ee7acad5ec9177fefac2991fe970338acc27efcc8a13ad"},{"asset_id":"PROFILE-X3_PROCEDURE_STANDING_RELIEF","binding_status":"BOUND","path":"profiles/crosscut/X3_procedure_standing_relief.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"f3b794bef82566e569232ba02c63ae148099143d8d1ab84de1c4fb76105e65df"},{"asset_id":"PROFILE-X4_RESPONSE_ADMISSION_DEFENSE","binding_status":"BOUND","path":"profiles/crosscut/X4_response_admission_defense.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"57851ed55b3351a8139df29224d74b7cb8427708bbf6de00ecd27c44089df32e"},{"asset_id":"PROFILE-SL-AUTO_MOTOR_VEHICLE","binding_status":"BOUND","path":"profiles/special_law/SL-AUTO_motor_vehicle.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7234a7ab890f242e6b7aa811528e34c0c85779007cffbf135da0bfff36d61d91"},{"asset_id":"PROFILE-SL-INDUSTRIAL_ACCIDENT","binding_status":"BOUND","path":"profiles/special_law/SL-INDUSTRIAL_ACCIDENT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"10d78b8031df7d89f835afc9ca60fab36648e561c729780204c80885f4dd097f"},{"asset_id":"PROFILE-SL-PRODUCT_LIABILITY","binding_status":"BOUND","path":"profiles/special_law/SL-PRODUCT_LIABILITY.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"1d5ee8eddcf005fdb33df58f591a8948aa3e891a3a5656d919394ff0b39eea53"},{"asset_id":"PROFILE-SL-RESIDENTIAL_LEASE","binding_status":"BOUND","path":"profiles/special_law/SL-RESIDENTIAL_LEASE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"3e2efd1b3c0524a305eafedc5ec91e05be989a6e55c1501ed161a9b8f8151fd7"},{"asset_id":"PROFILE-SL-COMMERCIAL_LEASE","binding_status":"BOUND","path":"profiles/special_law/SL-COMMERCIAL_LEASE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5aebed9ab56bc00eb7e0511f9fe5db8c3a42f1e81b28d58c38d487aa91cbab3e"},{"asset_id":"PROFILE-SL-LABOR","binding_status":"BOUND","path":"profiles/special_law/SL-LABOR.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6b2542bb64f4c1d164b1ccd2ce5099fad29bcea4333d9e34bd0fb1667b9ced4a"},{"asset_id":"PROFILE-SL-STATE_LIABILITY","binding_status":"BOUND","path":"profiles/special_law/SL-STATE_LIABILITY.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"5b2fe6d57b918384a619efbd04360ddfaf7720d384136f69d359ccb0b6c853d3"},{"asset_id":"PROFILE-SL-IP-PATENT","binding_status":"BOUND","path":"profiles/special_law/SL-IP-PATENT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d0651a8a50d0b18d25931063314ecec284988c5a18fab68d08a317d725bb3066"},{"asset_id":"PROFILE-SL-IP-COPYRIGHT","binding_status":"BOUND","path":"profiles/special_law/SL-IP-COPYRIGHT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"d4349677f68346f79709ea23a05957262f6426f976388bba45f05c617035eb78"},{"asset_id":"PROFILE-SL-IP-OTHER","binding_status":"BOUND","path":"profiles/special_law/SL-IP-OTHER.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fc3e2772252a3a90571663ebcfbc8e18dbf526977f4a3d77c4705ef8aa8dd6a8"},{"asset_id":"PROFILE-SL-MEDIA","binding_status":"BOUND","path":"profiles/special_law/SL-MEDIA.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"e0d5d287befd1578a06c64a265d5c4426af5772b6764018f6a15f00aac3b498c"},{"asset_id":"PROFILE-SL-TRANSPORT_MARITIME","binding_status":"BOUND","path":"profiles/special_law/SL-TRANSPORT_MARITIME.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"6e87a77c25f8c358f1d7d35ca165b1229c2cb422a440c91768ad80e520d35456"},{"asset_id":"PROFILE-SL-CONSUMER_CONTRACT","binding_status":"BOUND","path":"profiles/special_law/SL-CONSUMER_CONTRACT.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"afd8bbba102614d8d08f2e7a5384f6ca24e1309c1f52feb13906613f2ced51b7"},{"asset_id":"PROFILE-ACTIO-MORTGAGE","binding_status":"BOUND","path":"profiles/overlays/ACTIO-MORTGAGE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"7e584f7b4e4d19132e9575071f87d05965fb77fa2ca870911fe9974a7c511c4d"},{"asset_id":"PROFILE-ACTIO-MORTGAGE-CREATION","binding_status":"BOUND","path":"profiles/overlays/ACTIO-MORTGAGE-CREATION.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"e727690ee23883e011d49eba01cfd87abc5482641c2bda519c0a39518e1769ee"},{"asset_id":"PROFILE-ACTIO-ENCUMBERED-TRANSFER","binding_status":"BOUND","path":"profiles/overlays/ACTIO-ENCUMBERED-TRANSFER.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fa950393a572829ba7e296c20cd08ff19a063b0f8441f950130fd677b1e38179"},{"asset_id":"PROFILE-ACTIO-PRESERVED-CLAIM-BUNDLE","binding_status":"BOUND","path":"profiles/overlays/ACTIO-PRESERVED-CLAIM-BUNDLE.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"fbd99f029438c1c278f93d88d18a703db72e78f20c7049f344e5748c108f94c5"},{"asset_id":"PROFILE-ACTIO-DEFENSE-MAP","binding_status":"BOUND","path":"profiles/overlays/ACTIO-DEFENSE-MAP.yml","schema_id":"stage2.llm_context_profile.v1","sha256":"05348c493e6046a3e5c55f9b516c0e862fe5aa753e1b2fc71624bb2b11f0c191"}]},"executor_binding_ref":{"asset_id":"BINDING-S2_00-CODE-EXECUTOR","binding_status":"EXTERNAL_TRUST_ROOT_PENDING_LIVE_ADMISSION","path":"deployment/stage2_code_executor_binding.yml","schema_id":"stage2_code_executor_binding.v3"},"loader_binding_ref":{"asset_id":"BINDING-S2_00-LEGACY-REFERENCE","binding_status":"BOUND","path":"deployment/stage2_loader_binding.yml","schema_id":"stage2_loader_binding.reference.v1","sha256":"120313754c597541680a8dc7d9d59c6f8b2438c053553f030ef89171709dd23a"},"module_manifest_ref":{"asset_id":"MANIFEST-MODULE","binding_status":"BOUND","path":"manifest/module_manifest.json","schema_id":"stage2_module_manifest.v1","sha256":"cf7a2541abdaa86f807730ee4d312183b57bb74b20101e48cba510edc81362f8"},"open_items":[{"open_id":"O-07","owner":"release_operator","required_evidence":"signed canary or production admission with current Stage 1 integrity closure","status":"OPEN_RELEASE_AUTHORIZATION"},{"open_id":"CEG-02-DIRECT-MCP-LIVE","owner":"AgentBackend_owner","required_evidence":"live code-executor.run_code outer result and inner single-JSON receipt with exact Agent/code/release binding","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-03-SECRET-INJECTION","owner":"AgentBackend_owner","required_evidence":"backend-injected or pre-registered Code Executor authentication with no plaintext credential in YAML or code","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-04-RUNTIME-IMAGE-PIN","owner":"Code_Executor_owner","required_evidence":"verified Python runtime image digest compatible with the bound httpx dependency","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-05-REQUEST-SIZE-TIMEOUT","owner":"Code_Executor_owner","required_evidence":"representative S2_00 Agent request accepted and completed within backend request-size and 300-second limits","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-06-BINARY-LOCALDOCS","owner":"localdocs_owner","required_evidence":"live read_binary_doc and write_binary_file byte-preservation receipt over the approved path set","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-07-ISOLATION-EGRESS","owner":"AgentBackend_security_owner","required_evidence":"workspace identity substitution and backend-enforced S2_00_LOCALDOCS_ONLY_V1 egress verification","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"CEG-08-BARRIER-ROUTE","owner":"Stage_2_integration_owner","required_evidence":"live status-last logical publish and exactly-one downstream route receipt","status":"OPEN_EXTERNAL_BACKEND"},{"open_id":"DEV-DETACHED-RELEASE-ENVELOPE","owner":"release_operator","required_evidence":"detached signed envelope admits the release and executor binding without a cross-file hash cycle","status":"OPEN_RELEASE_AUTHORIZATION"},{"open_id":"DOWNSTREAM-CASE-TYPE-REGISTRY","owner":"S2_20_case_type_registry_owner","required_evidence":"manifest/case_type_registry.yml exact path/hash and 137-row sign-off; not a direct S2_00 executable dependency","status":"PENDING_SEQUENTIAL_BIND"}],"release_class":"DEV_FIXTURE_RELEASE","release_digest":"e533a83e51a6a71340b79f7caade858d67512b98642dd76eb3525cf065e58399","release_digest_contract":{"algorithm_id":"STAGE2-RELEASE-DIGEST-V1","array_order":"PRESERVE_DECLARED_ORDER","canonicalization_algorithm_id":"STAGE2-CANONICAL-JSON-V1","digest_algorithm":"sha256","digest_scope":"ENTIRE_DOCUMENT_AFTER_REMOVING_TOP_LEVEL_RELEASE_DIGEST","encoding":"UTF-8","line_termination":"LF_ONE_TRAILING_NEWLINE","non_finite_numbers_allowed":false,"object_key_order":"SORT_CODEPOINT"},"release_evidence":[{"evidence_id":"DEV-DRAFT-UNSIGNED-001","input_digest":"c2c6949b6ddfa1b74a048c633413f3452967155bcaa1110bcd41cde3aeceba8b","release_class":"DEV_FIXTURE_RELEASE","scope":"INLINE_CODE_EXECUTOR_AND_STRUCTURED_HANDOFF_OFFLINE_HASH_BOUND_VALIDATION_ONLY","signature":"PENDING_SEQUENTIAL_BIND","signer_id":"UNSIGNED_DRAFT","status":"PENDING_SEQUENTIAL_BIND"}],"release_id":"STAGE2-CLEAN-DEV-DRAFT-S2_00-HYBRID-HANDOFF-2026-08-30","release_status":"DRAFT_NOT_EXECUTABLE","retry_policies":[{"backoff_seconds":[0,1,3],"max_attempts":3,"non_retryable_classes":["HASH","SCHEMA","PRODUCER","CONSERVATION","RUN_BINDING"],"retry_policy_id":"S2-RETRY-TRANSIENT-READ-V1","retryable_codes":["TRANSIENT_READ_ERROR","TRANSIENT_LOCK_ERROR"]}],"schema_version":"stage2_release.v2","signature":"PENDING_SEQUENTIAL_BIND","stage1_sources":[{"adapter_id":"S2A-EVIDENCE-V3-ENVELOPE-V1","logical_input_id":"evidence_indexed","path":"evidence_indexed.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B1_quality_gate_evidence_indexed","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","items"],"requirement_class":"EVIDENCE_EVENT_SCOPE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-EVENTS-V1-ENVELOPE-V1","logical_input_id":"evidence_event_candidates","path":"evidence_event_candidates.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B2_quality_gate_event_candidates","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","items"],"requirement_class":"EVIDENCE_EVENT_SCOPE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-CLIENT-GOAL-V8-V1","logical_input_id":"client_goal","path":"client_goal.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_A_client_goal","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["primary_goal","constraints","parties"],"requirement_class":"OPTIMIZATION_CONTEXT","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-DOMAIN-SCREENING-V1","logical_input_id":"domain_screening","path":"routing/domain_screening.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_A0_domain_screener_02","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["domain_screening"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-DUAL-SG01-V1","logical_input_id":"domain_activation_manifest","path":"routing/domain_activation_manifest.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_D0_domain_activation_gate","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["domain_activation_manifest"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/s5/domain_activation_manifest.schema.json","path":"signals/schemas/domain_activation_manifest.schema.json","sha256":"013a6ebd230ebe46dda665af9f6c4448b267444b44e7b8f701f2fae80a2ee92a"},"transaction_identity_pointer":null},{"adapter_id":"S2A-B1-GATE-V1","logical_input_id":"b1_evidence_indexed_gate","path":"quality_gates/B1_evidence_indexed_gate.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B12_gate_audit_finalizer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","gate_id","overall_severity","hard_gate_findings","review_findings","stage2_auto_progression_allowed"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-B2-GATE-V1","logical_input_id":"b2_event_candidates_gate","path":"quality_gates/B2_event_candidates_gate.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B12_gate_audit_finalizer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_contract_version","gate_id","overall_severity","hard_gate_findings","review_findings","stage2_auto_progression_allowed"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-P1-HANDOFF-FLAT-V1","logical_input_id":"stage1_part1_soft_gate_handoff","path":"quality_gates/stage1_part1_soft_gate_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_B2_SHA256_soft_gate_handoff_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","handoff_status","review_items","stage2_auto_progression_allowed","hard_gate_summary","review_item_conservation","digest_guard"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-BO-V8-LIST-V1","logical_input_id":"bo","path":"BO.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"IDENTITY_BACKBONE","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-SIGNAL-ALL-V1","logical_input_id":"signal_manifest","path":"signals/signal_manifest.json","path_rule":null,"producer_alias_id":"PA-SG-COMPILER-001","producer_id":"Task_C_BO_S0_signal_bundle_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["files","downstream_read_sets"],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/s5/signal_manifest.schema.json","path":"signals/schemas/signal_manifest.schema.json","sha256":"5e72084780b82b29582c9ffcf48f3e4894d7c0b152e5ce8df394583c07dde681"},"transaction_identity_pointer":"/transaction_id"},{"adapter_id":"S2A-P2-HANDOFF-FLAT-V1","logical_input_id":"stage1_part2_review_handoff","path":"quality_gates/stage1_part2_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_BO_F0_final_bo_compiler_gate_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version","status","review_items"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-LES-CURRENT-V8-V1","logical_input_id":"legal_effect_structures","path":"legal_effect_structures.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_LE_L2_final_structure_index_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"ROUTING_PROFILE_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/part3/legal_effect_structures.schema.json","path":"platform/schemas/legal_effect_structures.schema.json","sha256":"fc962e8ae39f9bede64ba017297eded6413689204a065e00c3b3bdca8f1854df"},"transaction_identity_pointer":"/signal_manifest_transaction_id"},{"adapter_id":"S2A-P3-HANDOFF-WRAPPED-V1","logical_input_id":"stage1_part3_review_handoff","path":"quality_gates/stage1_part3_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_LE_L2_final_structure_index_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["stage1_part3_review_handoff"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-FACT-LEDGER-CURRENT-V8-V1","logical_input_id":"fact_ledger_base","path":"Fact_Ledger_base.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":[],"requirement_class":"IDENTITY_BACKBONE","run_identity_pointer":null,"schema_ref":{"$id":"https://schemas.liti-agent.local/stage1/part4/fact_ledger_base.schema.json","path":"platform/schemas/fact_ledger_base.schema.json","sha256":"b3f0e79ecb4c2f720f3e07e89154aadbd2327e4129cc703569fb5635240d2fe8"},"transaction_identity_pointer":null},{"adapter_id":"S2A-FACT-LEDGER-WRITER-REPORT-V1","logical_input_id":"fact_ledger_writer_report","path":"stage1_tmp/fact_ledger/fact_ledger_writer_report.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["schema_version"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-P4-HANDOFF-WRAPPED-V1","logical_input_id":"stage1_part4_review_handoff","path":"quality_gates/stage1_part4_review_handoff.json","path_rule":null,"producer_alias_id":null,"producer_id":"Task_C_FL_F2_final_fact_ledger_gate_and_writer","raw_hash_source":"UNAVAILABLE_DEV","required_keys":["stage1_part4_review_handoff"],"requirement_class":"INTEGRITY_CORROBORATOR","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null},{"adapter_id":"S2A-SIGNAL-ALL-V1","logical_input_id":"signal_payload_family","path":null,"path_rule":"signals/","producer_alias_id":"PA-SG-COMPILER-001","producer_id":"Task_C_BO_S0_signal_bundle_writer","raw_hash_source":"MANIFEST_ROW","required_keys":[],"requirement_class":"SIGNAL_PAYLOAD","run_identity_pointer":null,"schema_ref":null,"transaction_identity_pointer":null}]} diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.py index b3a45a11..2717cf24 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.py @@ -33,6 +33,8 @@ FORBIDDEN_PARENT_MEMBERS = frozenset( "agent_scripts/Stage_2_S2_00.yml", "runtime/s2_00_ingress.py", "runtime/s2_00_ingress.txt", + "runtime/s2_00_prepare_request.py", + "runtime/s2_00_prepare_request.txt", "manifest/s2_00_inline_code_receipt.json", "agent_scripts/Stage_2_S2_20.yml", "runtime/s2_20_reduce.py", diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.txt index b3a45a11..2717cf24 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_release_manifests.txt @@ -33,6 +33,8 @@ FORBIDDEN_PARENT_MEMBERS = frozenset( "agent_scripts/Stage_2_S2_00.yml", "runtime/s2_00_ingress.py", "runtime/s2_00_ingress.txt", + "runtime/s2_00_prepare_request.py", + "runtime/s2_00_prepare_request.txt", "manifest/s2_00_inline_code_receipt.json", "agent_scripts/Stage_2_S2_20.yml", "runtime/s2_20_reduce.py", diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.py index b08dafb3..1768c798 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.py @@ -32,10 +32,13 @@ AUTHORING_PATH = MAIN_WORKING_DIRECTORY / "Stage_2_S2_00_v.2.yml" PROJECTION_PATH = DEPLOYMENT_ROOT / "agent_scripts" / "Stage_2_S2_00.yml" MIRROR_PY_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_ingress.py" MIRROR_TXT_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_ingress.txt" +PREPARE_MIRROR_PY_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_prepare_request.py" +PREPARE_MIRROR_TXT_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_prepare_request.txt" RECEIPT_PATH = DEPLOYMENT_ROOT / "manifest" / "s2_00_inline_code_receipt.json" BINDING_PATH = DEPLOYMENT_ROOT / "deployment" / "stage2_code_executor_binding.yml" EXPECTED_TASK_NAME = "Task_S2_00_deterministic_ingress" +EXPECTED_PREPARE_TASK_NAME = "Task_S2_00_prepare_request" EXPECTED_AGENT_NAME = "Stage_2_S2_00_v2" EXPECTED_AGENT_VERSION = "1.2.0" EXPECTED_PARAMETERS = { @@ -252,6 +255,20 @@ def select_s2_00_binding(document: Mapping[str, Any]) -> dict[str, Any]: "expected": None, "observed": row.get("external_mcp_contract"), } + expected_prepare_contract = { + "task_name": EXPECTED_PREPARE_TASK_NAME, + "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "required_external_arguments": ["request_id", "attempt_id", "stage1_run_root_ref", "stage1_deployment_root_ref"], + "write_path": "stage2_control/s2_00_request.json", + "argument_binding_status": "UNVERIFIED", + "success_gate_status": "UNVERIFIED", + "workspace_serialization_status": "UNVERIFIED", + } + if row.get("prepare_request_contract") != expected_prepare_contract: + drift["prepare_request_contract"] = { + "expected": expected_prepare_contract, + "observed": row.get("prepare_request_contract"), + } if drift: raise ProjectionError( "S2_00_BINDING_SEMANTICS_DRIFT", @@ -280,7 +297,7 @@ def _require_list(value: Any, code: str) -> list[Any]: return value -def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: +def extract_run_code_tasks(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]: agent = _require_mapping(document.get("Agent"), "AGENT_OBJECT_REQUIRED") if agent.get("name") != EXPECTED_AGENT_NAME or agent.get("version") != EXPECTED_AGENT_VERSION: raise ProjectionError( @@ -324,9 +341,10 @@ def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], ) tasks = _require_list(stage.get("tasks"), "TASKS_ARRAY_REQUIRED") - if len(tasks) != 1: - raise ProjectionError("EXACTLY_ONE_TASK_REQUIRED", str(len(tasks))) - task = _require_mapping(tasks[0], "TASK_OBJECT_REQUIRED") + if len(tasks) != 2: + raise ProjectionError("EXACTLY_TWO_TASKS_REQUIRED", str(len(tasks))) + prepare_task = _require_mapping(tasks[0], "PREPARE_TASK_OBJECT_REQUIRED") + task = _require_mapping(tasks[1], "INGRESS_TASK_OBJECT_REQUIRED") run_code_tasks = [ row for row in tasks @@ -334,43 +352,54 @@ def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], and row.get("mcp") == "code-executor" and row.get("tool_name") == "run_code" ] - if len(run_code_tasks) != 1: - raise ProjectionError("EXACTLY_ONE_RUN_CODE_REQUIRED", str(len(run_code_tasks))) + if len(run_code_tasks) != 2: + raise ProjectionError("EXACTLY_TWO_RUN_CODE_REQUIRED", str(len(run_code_tasks))) + if prepare_task.get("task_name") != EXPECTED_PREPARE_TASK_NAME: + raise ProjectionError("PREPARE_TASK_NAME_MISMATCH", repr(prepare_task.get("task_name"))) if task.get("task_name") != EXPECTED_TASK_NAME: raise ProjectionError("TASK_NAME_MISMATCH", repr(task.get("task_name"))) - parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") - expected_parameter_keys = set(EXPECTED_PARAMETERS) | {"code"} - if set(parameters) != expected_parameter_keys: - raise ProjectionError( - "RUN_CODE_PARAMETER_SET_MISMATCH", - repr(sorted(parameters)), - ) - for key, expected in EXPECTED_PARAMETERS.items(): - if parameters.get(key) != expected: + for current in (prepare_task, task): + if current.get("mcp") != "code-executor" or current.get("tool_name") != "run_code": + raise ProjectionError("RUN_CODE_TOOL_MISMATCH", repr(current.get("task_name"))) + parameters = _require_mapping(current.get("parameters"), "TASK_PARAMETERS_REQUIRED") + expected_parameter_keys = set(EXPECTED_PARAMETERS) | {"code"} + if set(parameters) != expected_parameter_keys: raise ProjectionError( - "RUN_CODE_PARAMETER_MISMATCH", - f"{key}: expected {expected!r}, observed {parameters.get(key)!r}", + "RUN_CODE_PARAMETER_SET_MISMATCH", repr(sorted(parameters)), + ) + for key, expected in EXPECTED_PARAMETERS.items(): + if parameters.get(key) != expected: + raise ProjectionError( + "RUN_CODE_PARAMETER_MISMATCH", + f"{key}: expected {expected!r}, observed {parameters.get(key)!r}", + ) + code = parameters.get("code") + if not isinstance(code, str) or not code: + raise ProjectionError("INLINE_CODE_REQUIRED", repr(code)[:100]) + if code.endswith(("\n", "\r")): + raise ProjectionError( + "INLINE_CODE_TRAILING_NEWLINE_FORBIDDEN", + "authoring YAML must use code: |- so parser-returned code has no trailing newline", ) - code = parameters.get("code") - if not isinstance(code, str) or not code: - raise ProjectionError("INLINE_CODE_REQUIRED", repr(code)[:100]) - if code.endswith(("\n", "\r")): - raise ProjectionError( - "INLINE_CODE_TRAILING_NEWLINE_FORBIDDEN", - "authoring YAML must use code: |- so parser-returned code has no trailing newline", - ) procedure = _require_mapping(stage.get("task_procedure"), "TASK_PROCEDURE_REQUIRED") expected_procedure = { - "IN": {"nexts": [EXPECTED_TASK_NAME], "wait_until": []}, - EXPECTED_TASK_NAME: {"nexts": ["OUT"], "wait_until": ["IN"]}, + "IN": {"nexts": [EXPECTED_PREPARE_TASK_NAME], "wait_until": []}, + EXPECTED_PREPARE_TASK_NAME: {"nexts": [EXPECTED_TASK_NAME], "wait_until": ["IN"]}, + EXPECTED_TASK_NAME: {"nexts": ["OUT"], "wait_until": [EXPECTED_PREPARE_TASK_NAME]}, "OUT": {"nexts": [], "wait_until": [EXPECTED_TASK_NAME]}, } if procedure != expected_procedure: raise ProjectionError("TASK_PROCEDURE_MISMATCH", repr(procedure)[:500]) if stage.get("prevs") != [] or stage.get("nexts") != []: raise ProjectionError("STANDALONE_STAGE_EDGES_MUST_BE_EMPTY", repr(stage)) - return stage, task + return stage, prepare_task, task + + +def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: + """Compatibility accessor for the ingress task; validates the complete DAG.""" + stage, _prepare, ingress = extract_run_code_tasks(document) + return stage, ingress def _import_root(name: str | None) -> str: @@ -435,7 +464,7 @@ def _is_localdocs_endpoint(node: ast.expr) -> bool: ) -def validate_inline_code(code: str) -> dict[str, Any]: +def validate_inline_code(code: str, *, prepare: bool = False) -> dict[str, Any]: code_bytes = code.encode("utf-8") try: compile(code, "", "exec", dont_inherit=True) @@ -443,12 +472,19 @@ def validate_inline_code(code: str) -> dict[str, Any]: except (SyntaxError, ValueError, UnicodeError) as exc: raise ProjectionError("INLINE_CODE_COMPILE_FAILED", str(exc)) from exc - missing_tokens = [token for token in REQUIRED_CODE_TOKENS if token not in code] - missing_tokens.extend( - "|".join(alternatives) - for alternatives in REQUIRED_CODE_TOKEN_ALTERNATIVES - if not any(token in code for token in alternatives) + required_tokens = ( + (EXPECTED_LOCALDOCS_URL, "{{__user_hash__}}", "{{__workspace_hash__}}", + "build_request", "prepare_request", "write_binary_verified", + "read_binary_doc", "stage2_control/s2_00_request.json") + if prepare else REQUIRED_CODE_TOKENS ) + missing_tokens = [token for token in required_tokens if token not in code] + if not prepare: + missing_tokens.extend( + "|".join(alternatives) + for alternatives in REQUIRED_CODE_TOKEN_ALTERNATIVES + if not any(token in code for token in alternatives) + ) if missing_tokens: raise ProjectionError("INLINE_CODE_REQUIRED_TOKEN_MISSING", ",".join(missing_tokens)) if PLACEHOLDER_COMMENT_RE.search(code): @@ -651,6 +687,8 @@ def _canonical_task_semantics(document: Mapping[str, Any], stage: Mapping[str, A "MCP_SERVERS_OBJECT_REQUIRED", ) parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") + prepare_task = _require_list(stage.get("tasks"), "TASKS_ARRAY_REQUIRED")[0] + prepare_parameters = _require_mapping(prepare_task.get("parameters"), "PREPARE_PARAMETERS_REQUIRED") return { "agent": {"name": agent.get("name"), "version": agent.get("version")}, "stage": { @@ -663,6 +701,16 @@ def _canonical_task_semantics(document: Mapping[str, Any], stage: Mapping[str, A for name, value in sorted(servers.items()) if isinstance(value, dict) }, + "prepare_task": { + "task_name": prepare_task.get("task_name"), + "mcp": prepare_task.get("mcp"), + "tool_name": prepare_task.get("tool_name"), + "parameters": { + key: prepare_parameters.get(key) + for key in ("language", "requirements", "network", "timeout") + }, + "code_sha256": sha256_bytes(prepare_parameters["code"].encode("utf-8")), + }, "task": { "task_name": task.get("task_name"), "mcp": task.get("mcp"), @@ -681,7 +729,10 @@ def expected_outputs( authoring_raw: bytes, document: Mapping[str, Any], ) -> tuple[dict[Path, bytes], dict[str, Any]]: - stage, task = extract_run_code_task(document) + stage, prepare_task, task = extract_run_code_tasks(document) + prepare_code = _require_mapping(prepare_task.get("parameters"), "PREPARE_PARAMETERS_REQUIRED")["code"] + prepare_validation = validate_inline_code(prepare_code, prepare=True) + prepare_bytes = prepare_code.encode("utf-8") parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") code = parameters["code"] validation = validate_inline_code(code) @@ -709,12 +760,30 @@ def expected_outputs( "canonical_task_semantics_sha256": semantics_sha256, }, "canonical_code": { - "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "yaml_pointer": "/Agent/Stages/0/tasks/1/parameters/code", "encoding": "UTF-8", "extraction_transform": "NONE", **validation, }, + "prepare_code": { + "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "encoding": "UTF-8", + "extraction_transform": "NONE", + **prepare_validation, + }, "full_code_mirrors": [ + { + "path": _logical_path(PREPARE_MIRROR_PY_PATH), + "sha256": prepare_validation["code_sha256"], + "size_bytes": len(prepare_bytes), + "byte_identical_to_canonical_code": True, + }, + { + "path": _logical_path(PREPARE_MIRROR_TXT_PATH), + "sha256": prepare_validation["code_sha256"], + "size_bytes": len(prepare_bytes), + "byte_identical_to_canonical_code": True, + }, { "path": _logical_path(MIRROR_PY_PATH), "sha256": validation["code_sha256"], @@ -733,6 +802,8 @@ def expected_outputs( } outputs = { PROJECTION_PATH: authoring_raw, + PREPARE_MIRROR_PY_PATH: prepare_bytes, + PREPARE_MIRROR_TXT_PATH: prepare_bytes, MIRROR_PY_PATH: code_bytes, MIRROR_TXT_PATH: code_bytes, RECEIPT_PATH: canonical_json_bytes(receipt), diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.txt index b08dafb3..1768c798 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/offline_build/build_s2_00_inline_projection.txt @@ -32,10 +32,13 @@ AUTHORING_PATH = MAIN_WORKING_DIRECTORY / "Stage_2_S2_00_v.2.yml" PROJECTION_PATH = DEPLOYMENT_ROOT / "agent_scripts" / "Stage_2_S2_00.yml" MIRROR_PY_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_ingress.py" MIRROR_TXT_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_ingress.txt" +PREPARE_MIRROR_PY_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_prepare_request.py" +PREPARE_MIRROR_TXT_PATH = DEPLOYMENT_ROOT / "runtime" / "s2_00_prepare_request.txt" RECEIPT_PATH = DEPLOYMENT_ROOT / "manifest" / "s2_00_inline_code_receipt.json" BINDING_PATH = DEPLOYMENT_ROOT / "deployment" / "stage2_code_executor_binding.yml" EXPECTED_TASK_NAME = "Task_S2_00_deterministic_ingress" +EXPECTED_PREPARE_TASK_NAME = "Task_S2_00_prepare_request" EXPECTED_AGENT_NAME = "Stage_2_S2_00_v2" EXPECTED_AGENT_VERSION = "1.2.0" EXPECTED_PARAMETERS = { @@ -252,6 +255,20 @@ def select_s2_00_binding(document: Mapping[str, Any]) -> dict[str, Any]: "expected": None, "observed": row.get("external_mcp_contract"), } + expected_prepare_contract = { + "task_name": EXPECTED_PREPARE_TASK_NAME, + "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "required_external_arguments": ["request_id", "attempt_id", "stage1_run_root_ref", "stage1_deployment_root_ref"], + "write_path": "stage2_control/s2_00_request.json", + "argument_binding_status": "UNVERIFIED", + "success_gate_status": "UNVERIFIED", + "workspace_serialization_status": "UNVERIFIED", + } + if row.get("prepare_request_contract") != expected_prepare_contract: + drift["prepare_request_contract"] = { + "expected": expected_prepare_contract, + "observed": row.get("prepare_request_contract"), + } if drift: raise ProjectionError( "S2_00_BINDING_SEMANTICS_DRIFT", @@ -280,7 +297,7 @@ def _require_list(value: Any, code: str) -> list[Any]: return value -def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: +def extract_run_code_tasks(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any]]: agent = _require_mapping(document.get("Agent"), "AGENT_OBJECT_REQUIRED") if agent.get("name") != EXPECTED_AGENT_NAME or agent.get("version") != EXPECTED_AGENT_VERSION: raise ProjectionError( @@ -324,9 +341,10 @@ def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], ) tasks = _require_list(stage.get("tasks"), "TASKS_ARRAY_REQUIRED") - if len(tasks) != 1: - raise ProjectionError("EXACTLY_ONE_TASK_REQUIRED", str(len(tasks))) - task = _require_mapping(tasks[0], "TASK_OBJECT_REQUIRED") + if len(tasks) != 2: + raise ProjectionError("EXACTLY_TWO_TASKS_REQUIRED", str(len(tasks))) + prepare_task = _require_mapping(tasks[0], "PREPARE_TASK_OBJECT_REQUIRED") + task = _require_mapping(tasks[1], "INGRESS_TASK_OBJECT_REQUIRED") run_code_tasks = [ row for row in tasks @@ -334,43 +352,54 @@ def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], and row.get("mcp") == "code-executor" and row.get("tool_name") == "run_code" ] - if len(run_code_tasks) != 1: - raise ProjectionError("EXACTLY_ONE_RUN_CODE_REQUIRED", str(len(run_code_tasks))) + if len(run_code_tasks) != 2: + raise ProjectionError("EXACTLY_TWO_RUN_CODE_REQUIRED", str(len(run_code_tasks))) + if prepare_task.get("task_name") != EXPECTED_PREPARE_TASK_NAME: + raise ProjectionError("PREPARE_TASK_NAME_MISMATCH", repr(prepare_task.get("task_name"))) if task.get("task_name") != EXPECTED_TASK_NAME: raise ProjectionError("TASK_NAME_MISMATCH", repr(task.get("task_name"))) - parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") - expected_parameter_keys = set(EXPECTED_PARAMETERS) | {"code"} - if set(parameters) != expected_parameter_keys: - raise ProjectionError( - "RUN_CODE_PARAMETER_SET_MISMATCH", - repr(sorted(parameters)), - ) - for key, expected in EXPECTED_PARAMETERS.items(): - if parameters.get(key) != expected: + for current in (prepare_task, task): + if current.get("mcp") != "code-executor" or current.get("tool_name") != "run_code": + raise ProjectionError("RUN_CODE_TOOL_MISMATCH", repr(current.get("task_name"))) + parameters = _require_mapping(current.get("parameters"), "TASK_PARAMETERS_REQUIRED") + expected_parameter_keys = set(EXPECTED_PARAMETERS) | {"code"} + if set(parameters) != expected_parameter_keys: raise ProjectionError( - "RUN_CODE_PARAMETER_MISMATCH", - f"{key}: expected {expected!r}, observed {parameters.get(key)!r}", + "RUN_CODE_PARAMETER_SET_MISMATCH", repr(sorted(parameters)), + ) + for key, expected in EXPECTED_PARAMETERS.items(): + if parameters.get(key) != expected: + raise ProjectionError( + "RUN_CODE_PARAMETER_MISMATCH", + f"{key}: expected {expected!r}, observed {parameters.get(key)!r}", + ) + code = parameters.get("code") + if not isinstance(code, str) or not code: + raise ProjectionError("INLINE_CODE_REQUIRED", repr(code)[:100]) + if code.endswith(("\n", "\r")): + raise ProjectionError( + "INLINE_CODE_TRAILING_NEWLINE_FORBIDDEN", + "authoring YAML must use code: |- so parser-returned code has no trailing newline", ) - code = parameters.get("code") - if not isinstance(code, str) or not code: - raise ProjectionError("INLINE_CODE_REQUIRED", repr(code)[:100]) - if code.endswith(("\n", "\r")): - raise ProjectionError( - "INLINE_CODE_TRAILING_NEWLINE_FORBIDDEN", - "authoring YAML must use code: |- so parser-returned code has no trailing newline", - ) procedure = _require_mapping(stage.get("task_procedure"), "TASK_PROCEDURE_REQUIRED") expected_procedure = { - "IN": {"nexts": [EXPECTED_TASK_NAME], "wait_until": []}, - EXPECTED_TASK_NAME: {"nexts": ["OUT"], "wait_until": ["IN"]}, + "IN": {"nexts": [EXPECTED_PREPARE_TASK_NAME], "wait_until": []}, + EXPECTED_PREPARE_TASK_NAME: {"nexts": [EXPECTED_TASK_NAME], "wait_until": ["IN"]}, + EXPECTED_TASK_NAME: {"nexts": ["OUT"], "wait_until": [EXPECTED_PREPARE_TASK_NAME]}, "OUT": {"nexts": [], "wait_until": [EXPECTED_TASK_NAME]}, } if procedure != expected_procedure: raise ProjectionError("TASK_PROCEDURE_MISMATCH", repr(procedure)[:500]) if stage.get("prevs") != [] or stage.get("nexts") != []: raise ProjectionError("STANDALONE_STAGE_EDGES_MUST_BE_EMPTY", repr(stage)) - return stage, task + return stage, prepare_task, task + + +def extract_run_code_task(document: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: + """Compatibility accessor for the ingress task; validates the complete DAG.""" + stage, _prepare, ingress = extract_run_code_tasks(document) + return stage, ingress def _import_root(name: str | None) -> str: @@ -435,7 +464,7 @@ def _is_localdocs_endpoint(node: ast.expr) -> bool: ) -def validate_inline_code(code: str) -> dict[str, Any]: +def validate_inline_code(code: str, *, prepare: bool = False) -> dict[str, Any]: code_bytes = code.encode("utf-8") try: compile(code, "", "exec", dont_inherit=True) @@ -443,12 +472,19 @@ def validate_inline_code(code: str) -> dict[str, Any]: except (SyntaxError, ValueError, UnicodeError) as exc: raise ProjectionError("INLINE_CODE_COMPILE_FAILED", str(exc)) from exc - missing_tokens = [token for token in REQUIRED_CODE_TOKENS if token not in code] - missing_tokens.extend( - "|".join(alternatives) - for alternatives in REQUIRED_CODE_TOKEN_ALTERNATIVES - if not any(token in code for token in alternatives) + required_tokens = ( + (EXPECTED_LOCALDOCS_URL, "{{__user_hash__}}", "{{__workspace_hash__}}", + "build_request", "prepare_request", "write_binary_verified", + "read_binary_doc", "stage2_control/s2_00_request.json") + if prepare else REQUIRED_CODE_TOKENS ) + missing_tokens = [token for token in required_tokens if token not in code] + if not prepare: + missing_tokens.extend( + "|".join(alternatives) + for alternatives in REQUIRED_CODE_TOKEN_ALTERNATIVES + if not any(token in code for token in alternatives) + ) if missing_tokens: raise ProjectionError("INLINE_CODE_REQUIRED_TOKEN_MISSING", ",".join(missing_tokens)) if PLACEHOLDER_COMMENT_RE.search(code): @@ -651,6 +687,8 @@ def _canonical_task_semantics(document: Mapping[str, Any], stage: Mapping[str, A "MCP_SERVERS_OBJECT_REQUIRED", ) parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") + prepare_task = _require_list(stage.get("tasks"), "TASKS_ARRAY_REQUIRED")[0] + prepare_parameters = _require_mapping(prepare_task.get("parameters"), "PREPARE_PARAMETERS_REQUIRED") return { "agent": {"name": agent.get("name"), "version": agent.get("version")}, "stage": { @@ -663,6 +701,16 @@ def _canonical_task_semantics(document: Mapping[str, Any], stage: Mapping[str, A for name, value in sorted(servers.items()) if isinstance(value, dict) }, + "prepare_task": { + "task_name": prepare_task.get("task_name"), + "mcp": prepare_task.get("mcp"), + "tool_name": prepare_task.get("tool_name"), + "parameters": { + key: prepare_parameters.get(key) + for key in ("language", "requirements", "network", "timeout") + }, + "code_sha256": sha256_bytes(prepare_parameters["code"].encode("utf-8")), + }, "task": { "task_name": task.get("task_name"), "mcp": task.get("mcp"), @@ -681,7 +729,10 @@ def expected_outputs( authoring_raw: bytes, document: Mapping[str, Any], ) -> tuple[dict[Path, bytes], dict[str, Any]]: - stage, task = extract_run_code_task(document) + stage, prepare_task, task = extract_run_code_tasks(document) + prepare_code = _require_mapping(prepare_task.get("parameters"), "PREPARE_PARAMETERS_REQUIRED")["code"] + prepare_validation = validate_inline_code(prepare_code, prepare=True) + prepare_bytes = prepare_code.encode("utf-8") parameters = _require_mapping(task.get("parameters"), "TASK_PARAMETERS_REQUIRED") code = parameters["code"] validation = validate_inline_code(code) @@ -709,12 +760,30 @@ def expected_outputs( "canonical_task_semantics_sha256": semantics_sha256, }, "canonical_code": { - "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "yaml_pointer": "/Agent/Stages/0/tasks/1/parameters/code", "encoding": "UTF-8", "extraction_transform": "NONE", **validation, }, + "prepare_code": { + "yaml_pointer": "/Agent/Stages/0/tasks/0/parameters/code", + "encoding": "UTF-8", + "extraction_transform": "NONE", + **prepare_validation, + }, "full_code_mirrors": [ + { + "path": _logical_path(PREPARE_MIRROR_PY_PATH), + "sha256": prepare_validation["code_sha256"], + "size_bytes": len(prepare_bytes), + "byte_identical_to_canonical_code": True, + }, + { + "path": _logical_path(PREPARE_MIRROR_TXT_PATH), + "sha256": prepare_validation["code_sha256"], + "size_bytes": len(prepare_bytes), + "byte_identical_to_canonical_code": True, + }, { "path": _logical_path(MIRROR_PY_PATH), "sha256": validation["code_sha256"], @@ -733,6 +802,8 @@ def expected_outputs( } outputs = { PROJECTION_PATH: authoring_raw, + PREPARE_MIRROR_PY_PATH: prepare_bytes, + PREPARE_MIRROR_TXT_PATH: prepare_bytes, MIRROR_PY_PATH: code_bytes, MIRROR_TXT_PATH: code_bytes, RECEIPT_PATH: canonical_json_bytes(receipt), diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.py index b5ca7a39..c34ae3e8 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.py @@ -58,6 +58,8 @@ FORBIDDEN_PARENT_MEMBERS = frozenset( "agent_scripts/Stage_2_S2_00.yml", "runtime/s2_00_ingress.py", "runtime/s2_00_ingress.txt", + "runtime/s2_00_prepare_request.py", + "runtime/s2_00_prepare_request.txt", "manifest/s2_00_inline_code_receipt.json", "agent_scripts/Stage_2_S2_20.yml", "runtime/s2_20_reduce.py", diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.txt index b5ca7a39..c34ae3e8 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/release_ops/release_validator.txt @@ -58,6 +58,8 @@ FORBIDDEN_PARENT_MEMBERS = frozenset( "agent_scripts/Stage_2_S2_00.yml", "runtime/s2_00_ingress.py", "runtime/s2_00_ingress.txt", + "runtime/s2_00_prepare_request.py", + "runtime/s2_00_prepare_request.txt", "manifest/s2_00_inline_code_receipt.json", "agent_scripts/Stage_2_S2_20.yml", "runtime/s2_20_reduce.py", diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py index 386f61e6..13755580 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.py @@ -149,7 +149,7 @@ _RAW_VALUE_UNSET = object() # literal placeholders in the offline parity mirror and its unit tests. INLINE_USER_HASH = "{{__user_hash__}}" INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" INLINE_REQUEST_PATH = "stage2_control/s2_00_request.json" INLINE_STAGE2_ASSET_ROOT = "Default_Agent/Stage_2_Clean" INLINE_STAGE2_RELEASE_PATH = ( diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt index 386f61e6..13755580 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_ingress.txt @@ -149,7 +149,7 @@ _RAW_VALUE_UNSET = object() # literal placeholders in the offline parity mirror and its unit tests. INLINE_USER_HASH = "{{__user_hash__}}" INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" INLINE_REQUEST_PATH = "stage2_control/s2_00_request.json" INLINE_STAGE2_ASSET_ROOT = "Default_Agent/Stage_2_Clean" INLINE_STAGE2_RELEASE_PATH = ( diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.py new file mode 100644 index 00000000..0cc9706d --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +"""Prepare the fixed S2_00 control request from four explicit caller values. + +The backend argument-delivery contract is not bound. Direct execution fails +closed; callers must invoke ``prepare_request`` with the four named values. +""" + +from __future__ import annotations + +import base64 +import hashlib +import json +from pathlib import PurePosixPath +import re +import sys +import unicodedata +from typing import Any, Mapping + + +REQUEST_PATH = "stage2_control/s2_00_request.json" +LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" +MCP_PROTOCOL_VERSION = "2025-03-26" +INLINE_USER_HASH = "{{__user_hash__}}" +INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" +REQUEST_KEYS = frozenset({ + "schema_version", "workflow_id", "request_id", "attempt_id", + "stage1_run_root_ref", "stage1_deployment_root_ref", +}) +ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z") + + +class PrepareError(ValueError): + def __init__(self, code: str, message: str) -> None: + super().__init__(message) + self.code = code + + +def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, ensure_ascii=False, allow_nan=False, + sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8") + + +def _relative_path(value: str, *, code: str) -> str: + if not isinstance(value, str) or not value or "\x00" in value or "\\" in value: + raise PrepareError(code, "logical path is empty or malformed") + if unicodedata.normalize("NFC", value) != value: + raise PrepareError(code, "logical path must already be NFC") + path = PurePosixPath(value) + if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts): + raise PrepareError(code, "logical path must be a contained relative path") + rendered = path.as_posix() + if rendered != value: + raise PrepareError(code, "logical path is not canonical") + return rendered + + +def build_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, +) -> bytes: + """Return the exact six-field canonical request; do not access localdocs.""" + if not isinstance(request_id, str) or ID_RE.fullmatch(request_id) is None: + raise PrepareError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(attempt_id, str) or ID_RE.fullmatch(attempt_id) is None: + raise PrepareError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + request = { + "schema_version": "stage2_s2_00_execution_request.v1", + "workflow_id": "S2_00", + "request_id": request_id, + "attempt_id": attempt_id, + "stage1_run_root_ref": _relative_path( + stage1_run_root_ref, code="STAGE1_RUN_ROOT_REF_INVALID"), + "stage1_deployment_root_ref": _relative_path( + stage1_deployment_root_ref, code="STAGE1_DEPLOYMENT_ROOT_REF_INVALID"), + } + if set(request) != REQUEST_KEYS: + raise PrepareError("RUN_REQUEST_CLOSED_SHAPE", "request field set drifted") + return canonical_json_bytes(request) + + +class LocaldocsSession: + """Small localdocs JSON-RPC session with verified binary write/read-back.""" + + def __init__(self, user_hash: str, workspace_hash: str, *, client: Any = None) -> None: + for name, value in (("user_hash", user_hash), ("workspace_hash", workspace_hash)): + if not isinstance(value, str) or re.fullmatch(r"[a-f0-9]{64}", value) is None: + raise PrepareError("CONTEXT_HASH_INVALID", f"{name} is not a SHA-256 digest") + self.user_hash = user_hash + self.workspace_hash = workspace_hash + if client is None: + try: + import httpx + except ImportError as exc: + raise PrepareError("HTTPX_UNAVAILABLE", "httpx==0.28.1 is required") from exc + client = httpx.Client(timeout=60) + self.client = client + self.headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"} + self.session_id: str | None = None + self.next_id = 10 + self.initialized = False + + def close(self) -> None: + self.client.close() + + def _post(self, body: Mapping[str, Any], expected_id: int | None) -> Mapping[str, Any] | None: + try: + response = self.client.post(LOCALDOCS_URL, json=dict(body), headers=dict(self.headers)) + response.raise_for_status() + except Exception as exc: + raise PrepareError("MCP_TRANSPORT_ERROR", "localdocs transport failed") from exc + session_id = response.headers.get("mcp-session-id") + if session_id: + if self.session_id is None and expected_id == 1: + self.session_id = session_id + elif session_id != self.session_id: + raise PrepareError("MCP_SESSION_ID_CHANGED", "localdocs session changed") + self.headers["mcp-session-id"] = session_id + if expected_id is None: + return None + try: + payload = response.json() + except Exception as exc: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response is not JSON") from exc + if not isinstance(payload, dict) or payload.get("jsonrpc") != "2.0" or payload.get("id") != expected_id: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response ID or shape mismatch") + if "error" in payload or not isinstance(payload.get("result"), dict): + raise PrepareError("MCP_TOOL_ERROR", "localdocs returned an error") + return payload["result"] + + def initialize(self) -> None: + response = self._post({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { + "protocolVersion": MCP_PROTOCOL_VERSION, "capabilities": {}, "clientInfo": { + "name": "liti-s2-00-prepare", "version": "1.0.0", + "user_id": self.user_hash, "workspace_id": self.workspace_hash, + }}}, 1) + if response is None or response.get("protocolVersion") != MCP_PROTOCOL_VERSION or self.session_id is None: + raise PrepareError("MCP_INITIALIZE_INVALID", "localdocs initialization failed") + self._post({"jsonrpc": "2.0", "method": "notifications/initialized"}, None) + self.initialized = True + + def call(self, name: str, arguments: Mapping[str, Any]) -> Mapping[str, Any]: + if not self.initialized: + raise PrepareError("MCP_NOT_INITIALIZED", "localdocs is not initialized") + message_id = self.next_id + self.next_id += 1 + result = self._post({"jsonrpc": "2.0", "id": message_id, "method": "tools/call", + "params": {"name": name, "arguments": dict(arguments)}}, message_id) + if result is None or result.get("isError") is True: + raise PrepareError("MCP_TOOL_ERROR", f"localdocs {name} failed") + return result + + def read_binary(self, logical_path: str) -> bytes: + path = _relative_path(logical_path, code="LOCALDOCS_READ_PATH_INVALID") + result = self.call("read_binary_doc", {"doc_name": path}) + content = result.get("content") + if not isinstance(content, list) or len(content) != 1 or not isinstance(content[0], dict) or content[0].get("type") != "text": + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary response") + text = content[0].get("text") + if not isinstance(text, str): + raise PrepareError("LOCALDOCS_READ_SHAPE", "missing binary envelope") + try: + envelope = json.loads(text) + if isinstance(envelope, dict) and "results" in envelope: + rows = envelope["results"] + if not isinstance(rows, list) or len(rows) != 1 or not isinstance(rows[0], dict): + raise ValueError("binary result cardinality mismatch") + inner = rows[0].get("content", rows[0].get("text")) + envelope = json.loads(inner) if isinstance(inner, str) else inner + encoded = envelope["content_base64"] + if not isinstance(encoded, str): + raise ValueError("binary content is not base64") + payload = base64.b64decode(encoded, validate=True) + size = envelope.get("byte_length", envelope.get("size")) + if size is not None and (not isinstance(size, int) or size != len(payload)): + raise ValueError("binary size mismatch") + digest = envelope.get("sha256") + if digest is not None and digest != hashlib.sha256(payload).hexdigest(): + raise ValueError("binary hash mismatch") + return payload + except (ValueError, KeyError, TypeError, base64.binascii.Error) as exc: + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary envelope") from exc + + def write_binary_verified(self, logical_path: str, payload: bytes) -> str: + path = _relative_path(logical_path, code="LOCALDOCS_WRITE_PATH_INVALID") + if path != REQUEST_PATH: + raise PrepareError("LOCALDOCS_WRITE_PATH_INVALID", "prepare may write only the fixed request path") + result = self.call("write_binary_file", { + "path": path, "content_base64": base64.b64encode(payload).decode("ascii"), "overwrite": True, + }) + if not isinstance(result.get("content"), list) or result.get("isError") is True: + raise PrepareError("LOCALDOCS_WRITE_FAILED", "localdocs did not acknowledge write") + observed = self.read_binary(path) + if observed != payload: + raise PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "request read-back differs") + return hashlib.sha256(observed).hexdigest() + + +def prepare_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + *, + localdocs: Any = None, +) -> dict[str, Any]: + """Validate, write, read back, and close an authenticated localdocs session.""" + payload = build_request(request_id, attempt_id, stage1_run_root_ref, stage1_deployment_root_ref) + session = localdocs if localdocs is not None else LocaldocsSession(INLINE_USER_HASH, INLINE_WORKSPACE_HASH) + failure: Exception | None = None + digest: str | None = None + try: + session.initialize() + digest = session.write_binary_verified(REQUEST_PATH, payload) + except Exception as exc: + failure = exc + try: + session.close() + except Exception as exc: + if failure is None: + failure = PrepareError("LOCALDOCS_CLOSE_FAILED", "localdocs session close failed") + failure.__cause__ = exc + if failure is not None: + raise failure + return {"ok": True, "workflow_id": "S2_00", "path": REQUEST_PATH, + "request_sha256": digest} + + +if __name__ == "__main__": + sys.stdout.buffer.write(canonical_json_bytes({ + "ok": False, "error": {"code": "PREPARE_ARGUMENT_BINDING_UNVERIFIED", + "message": "four caller values must be bound by the backend"}})) + raise SystemExit(2) \ No newline at end of file diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.txt new file mode 100644 index 00000000..0cc9706d --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.txt @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +"""Prepare the fixed S2_00 control request from four explicit caller values. + +The backend argument-delivery contract is not bound. Direct execution fails +closed; callers must invoke ``prepare_request`` with the four named values. +""" + +from __future__ import annotations + +import base64 +import hashlib +import json +from pathlib import PurePosixPath +import re +import sys +import unicodedata +from typing import Any, Mapping + + +REQUEST_PATH = "stage2_control/s2_00_request.json" +LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" +MCP_PROTOCOL_VERSION = "2025-03-26" +INLINE_USER_HASH = "{{__user_hash__}}" +INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" +REQUEST_KEYS = frozenset({ + "schema_version", "workflow_id", "request_id", "attempt_id", + "stage1_run_root_ref", "stage1_deployment_root_ref", +}) +ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z") + + +class PrepareError(ValueError): + def __init__(self, code: str, message: str) -> None: + super().__init__(message) + self.code = code + + +def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, ensure_ascii=False, allow_nan=False, + sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8") + + +def _relative_path(value: str, *, code: str) -> str: + if not isinstance(value, str) or not value or "\x00" in value or "\\" in value: + raise PrepareError(code, "logical path is empty or malformed") + if unicodedata.normalize("NFC", value) != value: + raise PrepareError(code, "logical path must already be NFC") + path = PurePosixPath(value) + if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts): + raise PrepareError(code, "logical path must be a contained relative path") + rendered = path.as_posix() + if rendered != value: + raise PrepareError(code, "logical path is not canonical") + return rendered + + +def build_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, +) -> bytes: + """Return the exact six-field canonical request; do not access localdocs.""" + if not isinstance(request_id, str) or ID_RE.fullmatch(request_id) is None: + raise PrepareError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(attempt_id, str) or ID_RE.fullmatch(attempt_id) is None: + raise PrepareError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + request = { + "schema_version": "stage2_s2_00_execution_request.v1", + "workflow_id": "S2_00", + "request_id": request_id, + "attempt_id": attempt_id, + "stage1_run_root_ref": _relative_path( + stage1_run_root_ref, code="STAGE1_RUN_ROOT_REF_INVALID"), + "stage1_deployment_root_ref": _relative_path( + stage1_deployment_root_ref, code="STAGE1_DEPLOYMENT_ROOT_REF_INVALID"), + } + if set(request) != REQUEST_KEYS: + raise PrepareError("RUN_REQUEST_CLOSED_SHAPE", "request field set drifted") + return canonical_json_bytes(request) + + +class LocaldocsSession: + """Small localdocs JSON-RPC session with verified binary write/read-back.""" + + def __init__(self, user_hash: str, workspace_hash: str, *, client: Any = None) -> None: + for name, value in (("user_hash", user_hash), ("workspace_hash", workspace_hash)): + if not isinstance(value, str) or re.fullmatch(r"[a-f0-9]{64}", value) is None: + raise PrepareError("CONTEXT_HASH_INVALID", f"{name} is not a SHA-256 digest") + self.user_hash = user_hash + self.workspace_hash = workspace_hash + if client is None: + try: + import httpx + except ImportError as exc: + raise PrepareError("HTTPX_UNAVAILABLE", "httpx==0.28.1 is required") from exc + client = httpx.Client(timeout=60) + self.client = client + self.headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"} + self.session_id: str | None = None + self.next_id = 10 + self.initialized = False + + def close(self) -> None: + self.client.close() + + def _post(self, body: Mapping[str, Any], expected_id: int | None) -> Mapping[str, Any] | None: + try: + response = self.client.post(LOCALDOCS_URL, json=dict(body), headers=dict(self.headers)) + response.raise_for_status() + except Exception as exc: + raise PrepareError("MCP_TRANSPORT_ERROR", "localdocs transport failed") from exc + session_id = response.headers.get("mcp-session-id") + if session_id: + if self.session_id is None and expected_id == 1: + self.session_id = session_id + elif session_id != self.session_id: + raise PrepareError("MCP_SESSION_ID_CHANGED", "localdocs session changed") + self.headers["mcp-session-id"] = session_id + if expected_id is None: + return None + try: + payload = response.json() + except Exception as exc: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response is not JSON") from exc + if not isinstance(payload, dict) or payload.get("jsonrpc") != "2.0" or payload.get("id") != expected_id: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response ID or shape mismatch") + if "error" in payload or not isinstance(payload.get("result"), dict): + raise PrepareError("MCP_TOOL_ERROR", "localdocs returned an error") + return payload["result"] + + def initialize(self) -> None: + response = self._post({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { + "protocolVersion": MCP_PROTOCOL_VERSION, "capabilities": {}, "clientInfo": { + "name": "liti-s2-00-prepare", "version": "1.0.0", + "user_id": self.user_hash, "workspace_id": self.workspace_hash, + }}}, 1) + if response is None or response.get("protocolVersion") != MCP_PROTOCOL_VERSION or self.session_id is None: + raise PrepareError("MCP_INITIALIZE_INVALID", "localdocs initialization failed") + self._post({"jsonrpc": "2.0", "method": "notifications/initialized"}, None) + self.initialized = True + + def call(self, name: str, arguments: Mapping[str, Any]) -> Mapping[str, Any]: + if not self.initialized: + raise PrepareError("MCP_NOT_INITIALIZED", "localdocs is not initialized") + message_id = self.next_id + self.next_id += 1 + result = self._post({"jsonrpc": "2.0", "id": message_id, "method": "tools/call", + "params": {"name": name, "arguments": dict(arguments)}}, message_id) + if result is None or result.get("isError") is True: + raise PrepareError("MCP_TOOL_ERROR", f"localdocs {name} failed") + return result + + def read_binary(self, logical_path: str) -> bytes: + path = _relative_path(logical_path, code="LOCALDOCS_READ_PATH_INVALID") + result = self.call("read_binary_doc", {"doc_name": path}) + content = result.get("content") + if not isinstance(content, list) or len(content) != 1 or not isinstance(content[0], dict) or content[0].get("type") != "text": + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary response") + text = content[0].get("text") + if not isinstance(text, str): + raise PrepareError("LOCALDOCS_READ_SHAPE", "missing binary envelope") + try: + envelope = json.loads(text) + if isinstance(envelope, dict) and "results" in envelope: + rows = envelope["results"] + if not isinstance(rows, list) or len(rows) != 1 or not isinstance(rows[0], dict): + raise ValueError("binary result cardinality mismatch") + inner = rows[0].get("content", rows[0].get("text")) + envelope = json.loads(inner) if isinstance(inner, str) else inner + encoded = envelope["content_base64"] + if not isinstance(encoded, str): + raise ValueError("binary content is not base64") + payload = base64.b64decode(encoded, validate=True) + size = envelope.get("byte_length", envelope.get("size")) + if size is not None and (not isinstance(size, int) or size != len(payload)): + raise ValueError("binary size mismatch") + digest = envelope.get("sha256") + if digest is not None and digest != hashlib.sha256(payload).hexdigest(): + raise ValueError("binary hash mismatch") + return payload + except (ValueError, KeyError, TypeError, base64.binascii.Error) as exc: + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary envelope") from exc + + def write_binary_verified(self, logical_path: str, payload: bytes) -> str: + path = _relative_path(logical_path, code="LOCALDOCS_WRITE_PATH_INVALID") + if path != REQUEST_PATH: + raise PrepareError("LOCALDOCS_WRITE_PATH_INVALID", "prepare may write only the fixed request path") + result = self.call("write_binary_file", { + "path": path, "content_base64": base64.b64encode(payload).decode("ascii"), "overwrite": True, + }) + if not isinstance(result.get("content"), list) or result.get("isError") is True: + raise PrepareError("LOCALDOCS_WRITE_FAILED", "localdocs did not acknowledge write") + observed = self.read_binary(path) + if observed != payload: + raise PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "request read-back differs") + return hashlib.sha256(observed).hexdigest() + + +def prepare_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + *, + localdocs: Any = None, +) -> dict[str, Any]: + """Validate, write, read back, and close an authenticated localdocs session.""" + payload = build_request(request_id, attempt_id, stage1_run_root_ref, stage1_deployment_root_ref) + session = localdocs if localdocs is not None else LocaldocsSession(INLINE_USER_HASH, INLINE_WORKSPACE_HASH) + failure: Exception | None = None + digest: str | None = None + try: + session.initialize() + digest = session.write_binary_verified(REQUEST_PATH, payload) + except Exception as exc: + failure = exc + try: + session.close() + except Exception as exc: + if failure is None: + failure = PrepareError("LOCALDOCS_CLOSE_FAILED", "localdocs session close failed") + failure.__cause__ = exc + if failure is not None: + raise failure + return {"ok": True, "workflow_id": "S2_00", "path": REQUEST_PATH, + "request_sha256": digest} + + +if __name__ == "__main__": + sys.stdout.buffer.write(canonical_json_bytes({ + "ok": False, "error": {"code": "PREPARE_ARGUMENT_BINDING_UNVERIFIED", + "message": "four caller values must be bound by the backend"}})) + raise SystemExit(2) \ No newline at end of file diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py index f61de598..719df965 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.py @@ -27,7 +27,7 @@ from typing import Any, Iterable, Mapping, Sequence WORKFLOW_ID = "S2_20" ALGORITHM_VERSION = "s2_20_relief_plan/1.0.0" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" WEAVIATE_MCP_URL = "https://weaviate.eroomai.com/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt index f61de598..719df965 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_20_reduce.txt @@ -27,7 +27,7 @@ from typing import Any, Iterable, Mapping, Sequence WORKFLOW_ID = "S2_20" ALGORITHM_VERSION = "s2_20_relief_plan/1.0.0" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" WEAVIATE_MCP_URL = "https://weaviate.eroomai.com/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.py index f5d6af77..64523d5d 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.py @@ -18,7 +18,7 @@ import sys from typing import Any, Mapping -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.txt index f5d6af77..64523d5d 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_30_dispatch_planner.txt @@ -18,7 +18,7 @@ import sys from typing import Any, Mapping -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py index c706c1f2..cca9050e 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.py @@ -25,7 +25,7 @@ from typing import Any, Iterable, Mapping, Sequence WORKFLOW_ID = "S2_40" ALGORITHM_VERSION = "s2_40_finalizer/1.0.0" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt index c706c1f2..cca9050e 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/runtime/s2_40_commit.txt @@ -25,7 +25,7 @@ from typing import Any, Iterable, Mapping, Sequence WORKFLOW_ID = "S2_40" ALGORITHM_VERSION = "s2_40_finalizer/1.0.0" -EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" +EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/schemas/deployment.schema.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/schemas/deployment.schema.json index c993cd22..70793f42 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/schemas/deployment.schema.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/schemas/deployment.schema.json @@ -186,6 +186,20 @@ "expected_release_sha256": {"$ref": "#/$defs/bindable_sha256"}, "agent_script_sha256": {"$ref": "#/$defs/bindable_sha256"}, "canonical_code_sha256": {"$ref": "#/$defs/bindable_sha256"}, + "prepare_request_contract": { + "type": "object", + "additionalProperties": false, + "required": ["task_name", "yaml_pointer", "required_external_arguments", "write_path", "argument_binding_status", "success_gate_status", "workspace_serialization_status"], + "properties": { + "task_name": {"const": "Task_S2_00_prepare_request"}, + "yaml_pointer": {"const": "/Agent/Stages/0/tasks/0/parameters/code"}, + "required_external_arguments": {"const": ["request_id", "attempt_id", "stage1_run_root_ref", "stage1_deployment_root_ref"]}, + "write_path": {"const": "stage2_control/s2_00_request.json"}, + "argument_binding_status": {"const": "UNVERIFIED"}, + "success_gate_status": {"const": "UNVERIFIED"}, + "workspace_serialization_status": {"const": "UNVERIFIED"} + } + }, "mcp_server_id": {"const": "code-executor"}, "tool_name": {"const": "run_code"}, "language": {"const": "python"}, @@ -692,6 +706,7 @@ "authoring", "deployment_projection", "canonical_code", + "prepare_code", "full_code_mirrors", "task_contract", "parity_status" @@ -768,12 +783,55 @@ }, "placeholder_count": {"const": 0}, "plaintext_secret_count": {"const": 0}, + "yaml_pointer": {"const": "/Agent/Stages/0/tasks/1/parameters/code"} + } + }, + "prepare_code": { + "type": "object", + "additionalProperties": false, + "required": ["ast_status", "code_sha256", "code_size_bytes", "compile_status", "encoding", "external_python_source_ref_count", "external_url_count", "extraction_transform", "forbidden_dynamic_call_count", "forbidden_import_count", "imports", "placeholder_count", "plaintext_secret_count", "yaml_pointer"], + "properties": { + "ast_status": {"const": "PASS"}, + "code_sha256": {"$ref": "#/$defs/sha256"}, + "code_size_bytes": {"type": "integer", "minimum": 1}, + "compile_status": {"const": "PASS"}, + "encoding": {"const": "UTF-8"}, + "external_python_source_ref_count": {"const": 0}, + "external_url_count": {"const": 0}, + "extraction_transform": {"const": "NONE"}, + "forbidden_dynamic_call_count": {"const": 0}, + "forbidden_import_count": {"const": 0}, + "imports": {"type": "array", "items": {"$ref": "#/$defs/nonempty_string"}, "uniqueItems": true}, + "placeholder_count": {"const": 0}, + "plaintext_secret_count": {"const": 0}, "yaml_pointer": {"const": "/Agent/Stages/0/tasks/0/parameters/code"} } }, "full_code_mirrors": { "type": "array", "prefixItems": [ + { + "type": "object", + "additionalProperties": false, + "required": ["path", "sha256", "size_bytes", "byte_identical_to_canonical_code"], + "properties": { + "path": {"const": "Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.py"}, + "sha256": {"$ref": "#/$defs/sha256"}, + "size_bytes": {"type": "integer", "minimum": 1}, + "byte_identical_to_canonical_code": {"const": true} + } + }, + { + "type": "object", + "additionalProperties": false, + "required": ["path", "sha256", "size_bytes", "byte_identical_to_canonical_code"], + "properties": { + "path": {"const": "Default_Agent/Stage_2_Clean/runtime/s2_00_prepare_request.txt"}, + "sha256": {"$ref": "#/$defs/sha256"}, + "size_bytes": {"type": "integer", "minimum": 1}, + "byte_identical_to_canonical_code": {"const": true} + } + }, { "type": "object", "additionalProperties": false, @@ -798,13 +856,13 @@ } ], "items": false, - "minItems": 2, - "maxItems": 2 + "minItems": 4, + "maxItems": 4 }, "task_contract": { "type": "object", "additionalProperties": false, - "required": ["agent", "mcp_servers", "stage", "task", "task_procedure"], + "required": ["agent", "mcp_servers", "stage", "prepare_task", "task", "task_procedure"], "properties": { "agent": {"const": {"name": "Stage_2_S2_00_v2", "version": "1.2.0"}}, "mcp_servers": { @@ -814,6 +872,18 @@ } }, "stage": {"const": {"name": "S2_00", "nexts": [], "prevs": []}}, + "prepare_task": { + "type": "object", + "additionalProperties": false, + "required": ["task_name", "mcp", "tool_name", "parameters", "code_sha256"], + "properties": { + "task_name": {"const": "Task_S2_00_prepare_request"}, + "mcp": {"const": "code-executor"}, + "tool_name": {"const": "run_code"}, + "parameters": {"const": {"language": "python", "requirements": "httpx==0.28.1", "network": "agent-network", "timeout": 300}}, + "code_sha256": {"$ref": "#/$defs/sha256"} + } + }, "task": { "type": "object", "additionalProperties": false, @@ -835,8 +905,9 @@ }, "task_procedure": { "const": { - "IN": {"nexts": ["Task_S2_00_deterministic_ingress"], "wait_until": []}, - "Task_S2_00_deterministic_ingress": {"nexts": ["OUT"], "wait_until": ["IN"]}, + "IN": {"nexts": ["Task_S2_00_prepare_request"], "wait_until": []}, + "Task_S2_00_prepare_request": {"nexts": ["Task_S2_00_deterministic_ingress"], "wait_until": ["IN"]}, + "Task_S2_00_deterministic_ingress": {"nexts": ["OUT"], "wait_until": ["Task_S2_00_prepare_request"]}, "OUT": {"nexts": [], "wait_until": ["Task_S2_00_deterministic_ingress"]} } } diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/fixtures/regression_manifest.json b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/fixtures/regression_manifest.json index 203e92b3..fc0c9b3e 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/fixtures/regression_manifest.json +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/fixtures/regression_manifest.json @@ -1313,7 +1313,7 @@ }, { "path": "tests/s2_00/test_cluster_bundle_compile.py", - "sha256": "b643d2d4018ebe3349c64304063edf7ba0194fc92fb1fe9337eca3f384ae794a", + "sha256": "1b7a58ae53e7465cd39f0c911c4fab8e96b9e89df707eb9423e8a22fabc0a54b", "status": "DEV_HASH_BOUND" }, { @@ -1328,7 +1328,12 @@ }, { "path": "tests/s2_00/test_inline_code_parity.py", - "sha256": "8f0f55e8e1b970de572129946ab8bf34967c7fd84e316a9193509cab07a455ed", + "sha256": "325e0ed4dc7a4562b87946f2ff68693865997bd33b55ce5d0a6c558920404a18", + "status": "DEV_HASH_BOUND" + }, + { + "path": "tests/s2_00/test_prepare_request.py", + "sha256": "db76d064f742c2003eacfcb4814ba0b9d0b36984622147485cbab1139d5deaeb", "status": "DEV_HASH_BOUND" }, { diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.py index a817f95e..b5b636f9 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.py @@ -643,7 +643,10 @@ class ClusterAndBundleTests(unittest.TestCase): self.assertEqual(binding["expected_release_sha256"], binding["stage2_release_ref"]["sha256"]) self.assertEqual(binding["expected_release_sha256"], hashlib.sha256(release_path.read_bytes()).hexdigest()) agent = yaml.safe_load(agent_path.read_text(encoding="utf-8")) - code = agent["Agent"]["Stages"][0]["tasks"][0]["parameters"]["code"] + tasks = agent["Agent"]["Stages"][0]["tasks"] + self.assertEqual(tasks[0]["task_name"], "Task_S2_00_prepare_request") + self.assertEqual(tasks[1]["task_name"], "Task_S2_00_deterministic_ingress") + code = tasks[1]["parameters"]["code"] self.assertEqual(hashlib.sha256(code.encode("utf-8")).hexdigest(), binding["canonical_code_sha256"]) self.assertEqual(binding["agent_script_sha256"], binding["agent_script_ref"]["sha256"]) diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.txt index a817f95e..b5b636f9 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_cluster_bundle_compile.txt @@ -643,7 +643,10 @@ class ClusterAndBundleTests(unittest.TestCase): self.assertEqual(binding["expected_release_sha256"], binding["stage2_release_ref"]["sha256"]) self.assertEqual(binding["expected_release_sha256"], hashlib.sha256(release_path.read_bytes()).hexdigest()) agent = yaml.safe_load(agent_path.read_text(encoding="utf-8")) - code = agent["Agent"]["Stages"][0]["tasks"][0]["parameters"]["code"] + tasks = agent["Agent"]["Stages"][0]["tasks"] + self.assertEqual(tasks[0]["task_name"], "Task_S2_00_prepare_request") + self.assertEqual(tasks[1]["task_name"], "Task_S2_00_deterministic_ingress") + code = tasks[1]["parameters"]["code"] self.assertEqual(hashlib.sha256(code.encode("utf-8")).hexdigest(), binding["canonical_code_sha256"]) self.assertEqual(binding["agent_script_sha256"], binding["agent_script_ref"]["sha256"]) diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.py index 0b216f9c..e2aa8538 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.py +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.py @@ -38,6 +38,18 @@ def valid_inline_code() -> str: def authoring_yaml(code: str | None = None) -> bytes: source = valid_inline_code() if code is None else code indented = "\n".join(f" {line}" for line in source.split("\n")) + prepare_source = "\n".join( + f" {line}" for line in ( + "from __future__ import annotations\n" + "LOCALDOCS_URL = 'http://mcp-localdocs:8012/mcp'\n" + "USER_HASH = '{{__user_hash__}}'\n" + "WORKSPACE_HASH = '{{__workspace_hash__}}'\n" + "READ_TOOL = 'read_binary_doc'\n" + "REQUEST_PATH = 'stage2_control/s2_00_request.json'\n" + "def build_request():\n return b'{}'\n" + "def prepare_request():\n return 'write_binary_verified'" + ).split("\n") + ) return ( "Agent:\n" " name: Stage_2_S2_00_v2\n" @@ -53,6 +65,16 @@ def authoring_yaml(code: str | None = None) -> bytes: " type: streamable-http\n" " url: https://code-executor.mcp.eroomai.com/mcp\n" " tasks:\n" + " - task_name: Task_S2_00_prepare_request\n" + " mcp: code-executor\n" + " tool_name: run_code\n" + " parameters:\n" + " language: python\n" + " requirements: 'httpx==0.28.1'\n" + " network: agent-network\n" + " timeout: 300\n" + " code: |-\n" + f"{prepare_source}\n" " - task_name: Task_S2_00_deterministic_ingress\n" " mcp: code-executor\n" " tool_name: run_code\n" @@ -65,11 +87,14 @@ def authoring_yaml(code: str | None = None) -> bytes: f"{indented}\n" " task_procedure:\n" " IN:\n" - " nexts: [Task_S2_00_deterministic_ingress]\n" + " nexts: [Task_S2_00_prepare_request]\n" " wait_until: []\n" + " Task_S2_00_prepare_request:\n" + " nexts: [Task_S2_00_deterministic_ingress]\n" + " wait_until: [IN]\n" " Task_S2_00_deterministic_ingress:\n" " nexts: [OUT]\n" - " wait_until: [IN]\n" + " wait_until: [Task_S2_00_prepare_request]\n" " OUT:\n" " nexts: []\n" " wait_until: [Task_S2_00_deterministic_ingress]\n" @@ -129,6 +154,7 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): self.assertEqual(outputs[builder.PROJECTION_PATH], raw) self.assertEqual(outputs[builder.MIRROR_PY_PATH], valid_inline_code().encode("utf-8")) self.assertEqual(outputs[builder.MIRROR_TXT_PATH], outputs[builder.MIRROR_PY_PATH]) + self.assertEqual(outputs[builder.PREPARE_MIRROR_PY_PATH], outputs[builder.PREPARE_MIRROR_TXT_PATH]) parsed_receipt = json.loads(outputs[builder.RECEIPT_PATH]) self.assertEqual(parsed_receipt, receipt) self.assertEqual(parsed_receipt["parity_status"], "PASS") @@ -233,6 +259,8 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): projection = root / "agent_scripts" / "Stage_2_S2_00.yml" mirror_py = root / "runtime" / "s2_00_ingress.py" mirror_txt = root / "runtime" / "s2_00_ingress.txt" + prepare_py = root / "runtime" / "s2_00_prepare_request.py" + prepare_txt = root / "runtime" / "s2_00_prepare_request.txt" receipt = root / "manifest" / "s2_00_inline_code_receipt.json" root.mkdir(parents=True) original = authoring_yaml() @@ -244,6 +272,8 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): mock.patch.object(builder, "PROJECTION_PATH", projection), mock.patch.object(builder, "MIRROR_PY_PATH", mirror_py), mock.patch.object(builder, "MIRROR_TXT_PATH", mirror_txt), + mock.patch.object(builder, "PREPARE_MIRROR_PY_PATH", prepare_py), + mock.patch.object(builder, "PREPARE_MIRROR_TXT_PATH", prepare_txt), mock.patch.object(builder, "RECEIPT_PATH", receipt), ): status, payload = builder.run(check=False) @@ -253,6 +283,7 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): self.assertEqual(projection.read_bytes(), original) self.assertEqual(mirror_py.read_bytes(), valid_inline_code().encode("utf-8")) self.assertEqual(mirror_py.read_bytes(), mirror_txt.read_bytes()) + self.assertEqual(prepare_py.read_bytes(), prepare_txt.read_bytes()) receipt_before = receipt.read_bytes() status, payload = builder.run(check=True) self.assertEqual(status, 0) diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.txt index 0b216f9c..e2aa8538 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.txt +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_inline_code_parity.txt @@ -38,6 +38,18 @@ def valid_inline_code() -> str: def authoring_yaml(code: str | None = None) -> bytes: source = valid_inline_code() if code is None else code indented = "\n".join(f" {line}" for line in source.split("\n")) + prepare_source = "\n".join( + f" {line}" for line in ( + "from __future__ import annotations\n" + "LOCALDOCS_URL = 'http://mcp-localdocs:8012/mcp'\n" + "USER_HASH = '{{__user_hash__}}'\n" + "WORKSPACE_HASH = '{{__workspace_hash__}}'\n" + "READ_TOOL = 'read_binary_doc'\n" + "REQUEST_PATH = 'stage2_control/s2_00_request.json'\n" + "def build_request():\n return b'{}'\n" + "def prepare_request():\n return 'write_binary_verified'" + ).split("\n") + ) return ( "Agent:\n" " name: Stage_2_S2_00_v2\n" @@ -53,6 +65,16 @@ def authoring_yaml(code: str | None = None) -> bytes: " type: streamable-http\n" " url: https://code-executor.mcp.eroomai.com/mcp\n" " tasks:\n" + " - task_name: Task_S2_00_prepare_request\n" + " mcp: code-executor\n" + " tool_name: run_code\n" + " parameters:\n" + " language: python\n" + " requirements: 'httpx==0.28.1'\n" + " network: agent-network\n" + " timeout: 300\n" + " code: |-\n" + f"{prepare_source}\n" " - task_name: Task_S2_00_deterministic_ingress\n" " mcp: code-executor\n" " tool_name: run_code\n" @@ -65,11 +87,14 @@ def authoring_yaml(code: str | None = None) -> bytes: f"{indented}\n" " task_procedure:\n" " IN:\n" - " nexts: [Task_S2_00_deterministic_ingress]\n" + " nexts: [Task_S2_00_prepare_request]\n" " wait_until: []\n" + " Task_S2_00_prepare_request:\n" + " nexts: [Task_S2_00_deterministic_ingress]\n" + " wait_until: [IN]\n" " Task_S2_00_deterministic_ingress:\n" " nexts: [OUT]\n" - " wait_until: [IN]\n" + " wait_until: [Task_S2_00_prepare_request]\n" " OUT:\n" " nexts: []\n" " wait_until: [Task_S2_00_deterministic_ingress]\n" @@ -129,6 +154,7 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): self.assertEqual(outputs[builder.PROJECTION_PATH], raw) self.assertEqual(outputs[builder.MIRROR_PY_PATH], valid_inline_code().encode("utf-8")) self.assertEqual(outputs[builder.MIRROR_TXT_PATH], outputs[builder.MIRROR_PY_PATH]) + self.assertEqual(outputs[builder.PREPARE_MIRROR_PY_PATH], outputs[builder.PREPARE_MIRROR_TXT_PATH]) parsed_receipt = json.loads(outputs[builder.RECEIPT_PATH]) self.assertEqual(parsed_receipt, receipt) self.assertEqual(parsed_receipt["parity_status"], "PASS") @@ -233,6 +259,8 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): projection = root / "agent_scripts" / "Stage_2_S2_00.yml" mirror_py = root / "runtime" / "s2_00_ingress.py" mirror_txt = root / "runtime" / "s2_00_ingress.txt" + prepare_py = root / "runtime" / "s2_00_prepare_request.py" + prepare_txt = root / "runtime" / "s2_00_prepare_request.txt" receipt = root / "manifest" / "s2_00_inline_code_receipt.json" root.mkdir(parents=True) original = authoring_yaml() @@ -244,6 +272,8 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): mock.patch.object(builder, "PROJECTION_PATH", projection), mock.patch.object(builder, "MIRROR_PY_PATH", mirror_py), mock.patch.object(builder, "MIRROR_TXT_PATH", mirror_txt), + mock.patch.object(builder, "PREPARE_MIRROR_PY_PATH", prepare_py), + mock.patch.object(builder, "PREPARE_MIRROR_TXT_PATH", prepare_txt), mock.patch.object(builder, "RECEIPT_PATH", receipt), ): status, payload = builder.run(check=False) @@ -253,6 +283,7 @@ class InlineCodeProjectionUnitTests(unittest.TestCase): self.assertEqual(projection.read_bytes(), original) self.assertEqual(mirror_py.read_bytes(), valid_inline_code().encode("utf-8")) self.assertEqual(mirror_py.read_bytes(), mirror_txt.read_bytes()) + self.assertEqual(prepare_py.read_bytes(), prepare_txt.read_bytes()) receipt_before = receipt.read_bytes() status, payload = builder.run(check=True) self.assertEqual(status, 0) diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.py b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.py new file mode 100644 index 00000000..9e27dcc6 --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.py @@ -0,0 +1,171 @@ +from __future__ import annotations + +import json +from pathlib import Path +import sys +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT)) +from runtime import s2_00_ingress as ingress # noqa: E402 +from runtime import s2_00_prepare_request as prepare # noqa: E402 + + +ARGS = ("request-1", "attempt.1", "stage1/runs/matter-1", "stage1/deployment") + + +class FakeLocaldocs: + def __init__(self, *, fail_at: str | None = None) -> None: + self.fail_at = fail_at + self.initialized = False + self.closed = False + self.writes: list[tuple[str, bytes]] = [] + self.saved: bytes | None = None + + def initialize(self) -> None: + if self.fail_at == "initialize": + raise RuntimeError("initialize failed") + self.initialized = True + + def write_binary_verified(self, path: str, payload: bytes) -> str: + if self.fail_at == "write": + raise RuntimeError("write failed") + self.writes.append((path, payload)) + self.saved = payload + if self.fail_at == "readback": + raise prepare.PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "read-back differs") + return prepare.hashlib.sha256(payload).hexdigest() + + def close(self) -> None: + self.closed = True + if self.fail_at == "close": + raise RuntimeError("close failed") + + +class FakeResponse: + def __init__(self, payload: dict, *, session_id: str = "session-1") -> None: + self.payload = payload + self.headers = {"mcp-session-id": session_id} + + def raise_for_status(self) -> None: + return None + + def json(self) -> dict: + return self.payload + + +class FakeMcpClient: + def __init__(self, *, corrupt_read: bool = False) -> None: + self.corrupt_read = corrupt_read + self.saved: bytes | None = None + self.closed = False + self.calls: list[str] = [] + + def post(self, url: str, *, json: dict, headers: dict) -> FakeResponse: + if url != prepare.LOCALDOCS_URL: + raise RuntimeError("unexpected endpoint") + method = json["method"] + self.calls.append(method) + if method == "initialize": + result = {"protocolVersion": prepare.MCP_PROTOCOL_VERSION} + elif method == "notifications/initialized": + return FakeResponse({}) + else: + name = json["params"]["name"] + arguments = json["params"]["arguments"] + if name == "write_binary_file": + if arguments["path"] != prepare.REQUEST_PATH: + raise RuntimeError("wrong write path") + self.saved = prepare.base64.b64decode(arguments["content_base64"]) + text = "{}" + elif name == "read_binary_doc": + payload = b"corrupt" if self.corrupt_read else self.saved + text = prepare.json.dumps({"content_base64": prepare.base64.b64encode(payload).decode("ascii")}) + else: + raise RuntimeError("wrong tool") + result = {"content": [{"type": "text", "text": text}]} + return FakeResponse({"jsonrpc": "2.0", "id": json["id"], "result": result}) + + def close(self) -> None: + self.closed = True + + +class PrepareRequestTests(unittest.TestCase): + def test_exact_canonical_six_field_request_matches_existing_ingress(self) -> None: + payload = prepare.build_request(*ARGS) + value = json.loads(payload) + self.assertEqual(set(value), prepare.REQUEST_KEYS) + self.assertEqual(payload, ingress.canonical_json_bytes(value)) + self.assertEqual(ingress._inline_validate_request(payload), value) + self.assertTrue(payload.endswith(b"\n")) + + def test_invalid_inputs_never_write(self) -> None: + variants = [ + (123, *ARGS[1:]), + ("bad/id", *ARGS[1:]), + (ARGS[0], "bad id", *ARGS[2:]), + (*ARGS[:2], "../escape", ARGS[3]), + (*ARGS[:3], "/absolute"), + (*ARGS[:2], "stage1//run", ARGS[3]), + (*ARGS[:2], "stage1/e\u0301", ARGS[3]), + ] + for values in variants: + with self.subTest(values=values): + fake = FakeLocaldocs() + with self.assertRaises(prepare.PrepareError): + prepare.prepare_request(*values, localdocs=fake) + self.assertEqual(fake.writes, []) + + def test_verified_write_and_close(self) -> None: + fake = FakeLocaldocs() + result = prepare.prepare_request(*ARGS, localdocs=fake) + self.assertEqual(fake.writes, [(prepare.REQUEST_PATH, prepare.build_request(*ARGS))]) + self.assertTrue(fake.initialized) + self.assertTrue(fake.closed) + self.assertEqual(result["request_sha256"], prepare.hashlib.sha256(fake.saved).hexdigest()) + + def test_io_and_close_failures_do_not_return_success(self) -> None: + for failure in ("initialize", "write", "readback", "close"): + with self.subTest(failure=failure): + fake = FakeLocaldocs(fail_at=failure) + with self.assertRaises(Exception): + prepare.prepare_request(*ARGS, localdocs=fake) + self.assertTrue(fake.closed) + + def test_localdocs_write_path_is_fixed(self) -> None: + session = object.__new__(prepare.LocaldocsSession) + with self.assertRaises(prepare.PrepareError): + session.write_binary_verified("other/request.json", b"{}\n") + + def test_real_session_adapter_writes_and_reads_back_through_mcp(self) -> None: + client = FakeMcpClient() + session = prepare.LocaldocsSession("a" * 64, "b" * 64, client=client) + result = prepare.prepare_request(*ARGS, localdocs=session) + self.assertEqual(client.saved, prepare.build_request(*ARGS)) + self.assertEqual(result["request_sha256"], prepare.hashlib.sha256(client.saved).hexdigest()) + self.assertEqual(client.calls, ["initialize", "notifications/initialized", "tools/call", "tools/call"]) + self.assertTrue(client.closed) + + def test_real_session_adapter_rejects_readback_mismatch(self) -> None: + client = FakeMcpClient(corrupt_read=True) + session = prepare.LocaldocsSession("a" * 64, "b" * 64, client=client) + with self.assertRaises(prepare.PrepareError) as raised: + prepare.prepare_request(*ARGS, localdocs=session) + self.assertEqual(raised.exception.code, "LOCALDOCS_WRITE_READBACK_MISMATCH") + self.assertTrue(client.closed) + + def test_ingress_is_not_called_after_prepare_failure_in_local_flow(self) -> None: + calls: list[str] = [] + + def local_flow(fake: FakeLocaldocs) -> None: + prepare.prepare_request(*ARGS, localdocs=fake) + calls.append("ingress") + + with self.assertRaises(RuntimeError): + local_flow(FakeLocaldocs(fail_at="write")) + self.assertEqual(calls, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.txt b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.txt new file mode 100644 index 00000000..9e27dcc6 --- /dev/null +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/tests/s2_00/test_prepare_request.txt @@ -0,0 +1,171 @@ +from __future__ import annotations + +import json +from pathlib import Path +import sys +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT)) +from runtime import s2_00_ingress as ingress # noqa: E402 +from runtime import s2_00_prepare_request as prepare # noqa: E402 + + +ARGS = ("request-1", "attempt.1", "stage1/runs/matter-1", "stage1/deployment") + + +class FakeLocaldocs: + def __init__(self, *, fail_at: str | None = None) -> None: + self.fail_at = fail_at + self.initialized = False + self.closed = False + self.writes: list[tuple[str, bytes]] = [] + self.saved: bytes | None = None + + def initialize(self) -> None: + if self.fail_at == "initialize": + raise RuntimeError("initialize failed") + self.initialized = True + + def write_binary_verified(self, path: str, payload: bytes) -> str: + if self.fail_at == "write": + raise RuntimeError("write failed") + self.writes.append((path, payload)) + self.saved = payload + if self.fail_at == "readback": + raise prepare.PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "read-back differs") + return prepare.hashlib.sha256(payload).hexdigest() + + def close(self) -> None: + self.closed = True + if self.fail_at == "close": + raise RuntimeError("close failed") + + +class FakeResponse: + def __init__(self, payload: dict, *, session_id: str = "session-1") -> None: + self.payload = payload + self.headers = {"mcp-session-id": session_id} + + def raise_for_status(self) -> None: + return None + + def json(self) -> dict: + return self.payload + + +class FakeMcpClient: + def __init__(self, *, corrupt_read: bool = False) -> None: + self.corrupt_read = corrupt_read + self.saved: bytes | None = None + self.closed = False + self.calls: list[str] = [] + + def post(self, url: str, *, json: dict, headers: dict) -> FakeResponse: + if url != prepare.LOCALDOCS_URL: + raise RuntimeError("unexpected endpoint") + method = json["method"] + self.calls.append(method) + if method == "initialize": + result = {"protocolVersion": prepare.MCP_PROTOCOL_VERSION} + elif method == "notifications/initialized": + return FakeResponse({}) + else: + name = json["params"]["name"] + arguments = json["params"]["arguments"] + if name == "write_binary_file": + if arguments["path"] != prepare.REQUEST_PATH: + raise RuntimeError("wrong write path") + self.saved = prepare.base64.b64decode(arguments["content_base64"]) + text = "{}" + elif name == "read_binary_doc": + payload = b"corrupt" if self.corrupt_read else self.saved + text = prepare.json.dumps({"content_base64": prepare.base64.b64encode(payload).decode("ascii")}) + else: + raise RuntimeError("wrong tool") + result = {"content": [{"type": "text", "text": text}]} + return FakeResponse({"jsonrpc": "2.0", "id": json["id"], "result": result}) + + def close(self) -> None: + self.closed = True + + +class PrepareRequestTests(unittest.TestCase): + def test_exact_canonical_six_field_request_matches_existing_ingress(self) -> None: + payload = prepare.build_request(*ARGS) + value = json.loads(payload) + self.assertEqual(set(value), prepare.REQUEST_KEYS) + self.assertEqual(payload, ingress.canonical_json_bytes(value)) + self.assertEqual(ingress._inline_validate_request(payload), value) + self.assertTrue(payload.endswith(b"\n")) + + def test_invalid_inputs_never_write(self) -> None: + variants = [ + (123, *ARGS[1:]), + ("bad/id", *ARGS[1:]), + (ARGS[0], "bad id", *ARGS[2:]), + (*ARGS[:2], "../escape", ARGS[3]), + (*ARGS[:3], "/absolute"), + (*ARGS[:2], "stage1//run", ARGS[3]), + (*ARGS[:2], "stage1/e\u0301", ARGS[3]), + ] + for values in variants: + with self.subTest(values=values): + fake = FakeLocaldocs() + with self.assertRaises(prepare.PrepareError): + prepare.prepare_request(*values, localdocs=fake) + self.assertEqual(fake.writes, []) + + def test_verified_write_and_close(self) -> None: + fake = FakeLocaldocs() + result = prepare.prepare_request(*ARGS, localdocs=fake) + self.assertEqual(fake.writes, [(prepare.REQUEST_PATH, prepare.build_request(*ARGS))]) + self.assertTrue(fake.initialized) + self.assertTrue(fake.closed) + self.assertEqual(result["request_sha256"], prepare.hashlib.sha256(fake.saved).hexdigest()) + + def test_io_and_close_failures_do_not_return_success(self) -> None: + for failure in ("initialize", "write", "readback", "close"): + with self.subTest(failure=failure): + fake = FakeLocaldocs(fail_at=failure) + with self.assertRaises(Exception): + prepare.prepare_request(*ARGS, localdocs=fake) + self.assertTrue(fake.closed) + + def test_localdocs_write_path_is_fixed(self) -> None: + session = object.__new__(prepare.LocaldocsSession) + with self.assertRaises(prepare.PrepareError): + session.write_binary_verified("other/request.json", b"{}\n") + + def test_real_session_adapter_writes_and_reads_back_through_mcp(self) -> None: + client = FakeMcpClient() + session = prepare.LocaldocsSession("a" * 64, "b" * 64, client=client) + result = prepare.prepare_request(*ARGS, localdocs=session) + self.assertEqual(client.saved, prepare.build_request(*ARGS)) + self.assertEqual(result["request_sha256"], prepare.hashlib.sha256(client.saved).hexdigest()) + self.assertEqual(client.calls, ["initialize", "notifications/initialized", "tools/call", "tools/call"]) + self.assertTrue(client.closed) + + def test_real_session_adapter_rejects_readback_mismatch(self) -> None: + client = FakeMcpClient(corrupt_read=True) + session = prepare.LocaldocsSession("a" * 64, "b" * 64, client=client) + with self.assertRaises(prepare.PrepareError) as raised: + prepare.prepare_request(*ARGS, localdocs=session) + self.assertEqual(raised.exception.code, "LOCALDOCS_WRITE_READBACK_MISMATCH") + self.assertTrue(client.closed) + + def test_ingress_is_not_called_after_prepare_failure_in_local_flow(self) -> None: + calls: list[str] = [] + + def local_flow(fake: FakeLocaldocs) -> None: + prepare.prepare_request(*ARGS, localdocs=fake) + calls.append("ingress") + + with self.assertRaises(RuntimeError): + local_flow(FakeLocaldocs(fail_at="write")) + self.assertEqual(calls, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml index ee1c27a4..12cc5c35 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml @@ -22,8 +22,8 @@ Agent: - name: S2_00 description: >- C00, C05, C10, C15의 IO·순서·분기·배리어를 선언하는 NON-LLM 계약. - 실행 Python은 이 문서가 아니라 Agent YAML의 exactly-one - code-executor.run_code task에만 존재한다. + 실행 Python은 Agent YAML의 request 준비와 ingress 두 + code-executor.run_code task에 존재한다. prevs: [] nexts: - S2_10 @@ -102,8 +102,13 @@ Agent: requirements: "httpx==0.28.1" network_profile: agent-network timeout_seconds: 300 - inline_task_count: 1 - executable_task_owner_ref: agent_scripts/Stage_2_S2_00.yml#/Agent/Stages/0/tasks/0 + inline_task_count: 2 + prepare_task_owner_ref: agent_scripts/Stage_2_S2_00.yml#/Agent/Stages/0/tasks/0 + executable_task_owner_ref: agent_scripts/Stage_2_S2_00.yml#/Agent/Stages/0/tasks/1 + task_order: [Task_S2_00_prepare_request, Task_S2_00_deterministic_ingress] + backend_argument_binding_status: UNVERIFIED + backend_success_gate_status: UNVERIFIED + workspace_serialization_status: UNVERIFIED retry_policy_id: S2-RETRY-TRANSIENT-READ-V1 retry_policy_ref: manifest/stage2_release.json#/retry_policies/0 idempotence_key_material: @@ -122,6 +127,14 @@ Agent: request_contract: fixed_path: stage2_control/s2_00_request.json + producer_task: Task_S2_00_prepare_request + producer_write_path: stage2_control/s2_00_request.json + external_argument_delivery_status: UNVERIFIED + required_external_arguments: + - request_id + - attempt_id + - stage1_run_root_ref + - stage1_deployment_root_ref schema_ref: schemas/ingress.schema.json#/$defs/execution_request directory_scan_allowed: false alternate_request_path_allowed: false @@ -383,7 +396,7 @@ Agent: llm_calls_allowed: false llm_configuration_present: false inline_python_allowed_in_workflow_contract: false - executable_inline_python_owner: agent_scripts/Stage_2_S2_00.yml#/Agent/Stages/0/tasks/0/parameters/code + executable_inline_python_owner: agent_scripts/Stage_2_S2_00.yml#/Agent/Stages/0/tasks/1/parameters/code inline_schema_allowed: false external_internet_access_allowed: false mcp_endpoint_allowlist: diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/MEMORY.md b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/MEMORY.md index 1bf0250c..244a2b7a 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/MEMORY.md +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/MEMORY.md @@ -16,6 +16,19 @@ - 하위 에이전트(subagents)를 사용하여 핵심 테마와 교훈을 식별하고 MEMORY.md에 섹션으로 저장하라. - 향후 세션 시작 시 MEMORY.md의 이전 섹션을 참조하라. +## 2026-10-01 — 현행 S2_00 배포 YAML 분석 + +한 줄 요약: `Default_Agent/Stage_2_Clean/agent_scripts/Analysis_Stage_2_S2_00.md`에 현행 두-task DAG, C00–C15의 단일 ingress 실행 경계, 고정·동적 입력과 분기별 출력, 배포 자산·후속 route를 기록했다. prepare 함수의 request 저장 구현과 배포 YAML의 직접 실행 가능성을 구분하는 것이 핵심이다. 현재 네 외부 인자 결속·실패 차단·workspace 직렬화는 미검증이고, 직접 실행은 fail closed하며 DEV fixture release는 실제 사건 발행을 금지한다. + +## 2026-10-01 — S2_00 request 준비 코드·두 task YAML + +한 줄 요약: 기존 배포 YAML을 `Stage_2_S2_00_outdated_10_01.yml`로 byte-identical 보존하고, 현행 S2_00 앞단에 네 인자→정확히 6필드 canonical JSON 생성·검증·localdocs 고정 경로 write/read-back을 수행하는 `Task_S2_00_prepare_request`를 추가했다. authoring/deployment YAML, 두 code mirror와 receipt, builder·workflow·binding·schema·회귀시험 및 영향받은 parent/child release hash 참조를 갱신했다. 함수·가짜 localdocs 및 정적 projection/release 검증은 통과했지만 backend의 네 인자 주입·prepare 실패 후 ingress 차단·동일 workspace 직렬화는 미확인이다. 직접 `run_code`는 인자 미결속 오류로 fail closed하며 DEV release도 계속 `DRAFT_NOT_EXECUTABLE`이다. S2_20 전체 시험의 case catalog 1건 실패는 별도 미추적 `Case_02_Comparison_Research/case_kinds.md`와 기존 registry의 불일치로 남겼고 해당 자료는 변경하지 않았다. + + + +## 2026-10-01 — S2_00 request 준비 계획 v2 + +한 줄 요약: `plans/s2-00-request-preparation_v2.md`를 작성해, 네 인자 함수의 6필드 JSON 생성·검증·localdocs 저장/read-back과 Stage 2 작업명세서 첫 task 배치를 backend 확인 전에 구현·offline 시험하도록 순서를 개정했다. 실제 인자 주입·prepare 실패 차단·workspace 직렬화는 운영 연결 검증으로 남기며, v2 작성만으로 YAML·request 생성이나 live-ready 상태를 주장하지 않는다. ## 2026-09-30 — S2_00 IO 분석·request 준비 계획 및 구현 경계 정정 diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_Analysis_v1.md b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_Analysis_v1.md index 98a21b15..01226901 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_Analysis_v1.md +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_Analysis_v1.md @@ -1,10 +1,17 @@ # Stage 2_00 작업분석서 +## 2026-10-01 현행 구현 보충 + +아래 2026-09-09 분석과 `Y:행번호`는 [보존된 당시 배포본](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml)에 관한 기록이다. [현행 배포본](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml)은 `IN → Task_S2_00_prepare_request → Task_S2_00_deterministic_ingress → OUT`의 두 task DAG로 바뀌었다. 첫 task의 `build_request(request_id, attempt_id, stage1_run_root_ref, stage1_deployment_root_ref)`는 기존 ID·NFC 상대경로 규칙으로 정확히 6필드의 canonical UTF-8 JSON bytes를 만들고, `prepare_request`는 localdocs의 `stage2_control/s2_00_request.json`에 binary write/read-back한 후 세션을 닫는다. ingress의 C00–C15 및 기존 출력 계약은 유지된다. 준비 code의 별도 `.py/.txt` mirror와 두 task pointer/hash는 inline receipt에 기록된다. + +현재 inline `run_code`에 네 인자를 주입하는 backend 문법이 확인되지 않아 준비 task의 직접 실행은 `PREPARE_ARGUMENT_BINDING_UNVERIFIED`와 exit 2로 실패한다. YAML의 edge가 backend의 성공 조건·동일 workspace 직렬화를 실제로 강제하는지도 미검증이다. 생성 함수·격리 localdocs 시험과 배포본의 정적 결속은 완료했으나 실사건 Stage 2 실행 적격성은 입증하지 않았다. 아래 본문에서 “단일 task”, 외부 request producer, 행번호라고 적힌 부분은 **보존본 분석 시점의 사실**로 읽어야 한다. + + ## 0. 분석 범위와 결론 -분석 기준일은 2026-09-09이다. 분석 정본은 [배포 Stage_2_S2_00.yml](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml) **1–6,248행 전체**, SHA-256 `94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943`이다. 이 문서에서 `Y:번호`는 이 배포 YAML의 행번호이며, 각 절의 링크와 함께 읽는다. 실제 구현을 우선하고 [S2_00_SOW_v.2.md](S2_00_SOW_v.2.md), [S2_00_assets_v.2.md](S2_00_assets_v.2.md), [workflow 계약](Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml), [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json)는 의도·배포계약과의 대조에 사용했다. JSON이 한 행으로 저장된 release는 행번호 대신 JSON Pointer로 특정한다. +분석 기준일은 2026-09-09이다. 분석 정본은 [배포 Stage_2_S2_00.yml](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml) **1–6,248행 전체**, SHA-256 `94c2744d71d222cfb5cc1b2a0d33a6cda20079439823de431eef378a2fa5c943`이다. 이 문서에서 `Y:번호`는 이 배포 YAML의 행번호이며, 각 절의 링크와 함께 읽는다. 실제 구현을 우선하고 [S2_00_SOW_v.2.md](S2_00_SOW_v.2.md), [S2_00_assets_v.2.md](S2_00_assets_v.2.md), [workflow 계약](Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml), [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json)는 의도·배포계약과의 대조에 사용했다. JSON이 한 행으로 저장된 release는 행번호 대신 JSON Pointer로 특정한다. -S2_00은 **Stage 1 자료를 받아 후속 법률판단에 사용할 입력을 구성하는 단일 deterministic ingress task**다. Stage 1의 사실·증거·구조·signal·review를 검사하고, context·claim-neutral cluster·slice·S2_10용 structured-context handoff를 만든다. 청구권의 성립, 청구취지, 청구원인 문안을 LLM으로 판단하지 않는다. C00·C05·C10·C15는 한 Python 호출 안의 논리적 구성요소이며 네 개 Agent task가 아니다. `Agent.Stages[0].prevs`와 `nexts`는 모두 빈 배열이므로 전체 Stage 2 연결은 YAML 내부 stage edge가 아니라 **출력 barrier의 route와 외부 orchestrator**로 성립한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:1–43, 6018–6103, 6230–6248. +S2_00은 **Stage 1 자료를 받아 후속 법률판단에 사용할 입력을 구성하는 단일 deterministic ingress task**다. Stage 1의 사실·증거·구조·signal·review를 검사하고, context·claim-neutral cluster·slice·S2_10용 structured-context handoff를 만든다. 청구권의 성립, 청구취지, 청구원인 문안을 LLM으로 판단하지 않는다. C00·C05·C10·C15는 한 Python 호출 안의 논리적 구성요소이며 네 개 Agent task가 아니다. `Agent.Stages[0].prevs`와 `nexts`는 모두 빈 배열이므로 전체 Stage 2 연결은 YAML 내부 stage edge가 아니라 **출력 barrier의 route와 외부 orchestrator**로 성립한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:1–43, 6018–6103, 6230–6248. 다만 현재 코드와 배포계약만으로 “Stage 1 자료가 충분히 보존된 실행 가능한 S2_10 입력이 완성된다”고 단정할 수 없다. 현재 release는 `DEV_FIXTURE_RELEASE / DRAFT_NOT_EXECUTABLE`, bundle은 `STRUCTURAL_FIXTURE`, selected context는 빈 배열이다. 또한 source-family adapter 불일치, provenance pointer 불일치, 일부 자료의 slice 미편입 및 core와 MCP 진입경로의 실패처리 차이가 존재한다. 이들은 §8에 실제 구현의 제한으로 별도 기재했다. MEMORY의 240/240 등은 이전 작업 기록이며 본 분석에서 새로 실행한 시험 결과가 아니다. @@ -20,7 +27,7 @@ S2_00은 **Stage 1 자료를 받아 후속 법률판단에 사용할 입력을 | `O/` | `W/stage2_runs/by-binding//` | | `T/` | Code Executor에서 `TemporaryDirectory(prefix="liti-s2-00-")`로 만드는 임시 root | -`W/Default_Agent/Stage_2_Clean`가 live 자산 root다. 저장소의 `R/`는 그 배포 패키지의 로컬 위치다. request가 임의 output root나 release path를 전달할 수는 없다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:194–205, 5548–5591, 5957–5959. +`W/Default_Agent/Stage_2_Clean`가 live 자산 root다. 저장소의 `R/`는 그 배포 패키지의 로컬 위치다. request가 임의 output root나 release path를 전달할 수는 없다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:194–205, 5548–5591, 5957–5959. ## 1. 전체 작업 DAG @@ -95,13 +102,13 @@ stdout 단일 JSON inner receipt + exit 0 (저장 이후 read-back/close 실패도 같은 label; 저장상태 재확인 필요) ``` -위 도식의 C00–C15는 작업 책임을 묶은 것이다. `execute_ingress`는 마지막에 manifest/intake/issue/status를 조립해 일괄 발행하므로 C00 또는 C10 진입 직후 해당 파일이 이미 외부에 저장되는 것은 아니다. 로컬 `os.rename`과 원격 `STATUS_LAST_LOGICAL_COMMIT`은 서로 다른 보장이다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:4015–4108, 4801–5243, 5896–6103. +위 도식의 C00–C15는 작업 책임을 묶은 것이다. `execute_ingress`는 마지막에 manifest/intake/issue/status를 조립해 일괄 발행하므로 C00 또는 C10 진입 직후 해당 파일이 이미 외부에 저장되는 것은 아니다. 로컬 `os.rename`과 원격 `STATUS_LAST_LOGICAL_COMMIT`은 서로 다른 보장이다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:4015–4108, 4801–5243, 5896–6103. ## 2. IO 구조 ### 2.1 외부 제어 입력과 Stage 1 사건 입력 -모든 아래 파일은 JSON이다. 이 표의 producer는 현 parent release `/stage1_sources`에 선언된 expected producer이며, 실제 Stage 1 사건 실행 사실을 확인했다는 의미가 아니다. raw source는 strict UTF-8, duplicate JSON key 및 NaN/Infinity 거부, 기본 파일당 32 MiB/run 256 MiB/depth 96/items 1,000,000 제한을 적용한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:83–87, 211–227, 299–329, 1084–1392. +모든 아래 파일은 JSON이다. 이 표의 producer는 현 parent release `/stage1_sources`에 선언된 expected producer이며, 실제 Stage 1 사건 실행 사실을 확인했다는 의미가 아니다. raw source는 strict UTF-8, duplicate JSON key 및 NaN/Infinity 거부, 기본 파일당 32 MiB/run 256 MiB/depth 96/items 1,000,000 제한을 적용한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:83–87, 211–227, 299–329, 1084–1392. | 입력 exact path | producer/공급자 | C00 이후의 사용 | |---|---|---| @@ -125,13 +132,13 @@ stdout 단일 JSON inner receipt + exit 0 | `U/quality_gates/stage1_part4_review_handoff.json` | `Task_C_FL_F2_final_fact_ledger_gate_and_writer` | wrapped review 정규화·count | | `U/signals/` | signal compiler, alias `PA-SG-COMPILER-001` | 유일한 manifest-expanded 가변 input family. `signals/` 중복 prefix 금지 | -Stage 1의 16개 고정 입력과 signal family를 구분한다. manifest row의 `canonical`·`domain_signal`은 의미 입력, `compatibility_view`는 파일 무결성만 검사하는 입력이다. signal ID 하나로 deduplicate하지 않고 `(transaction, file_path, record_ordinal, signal_id)` 발생 단위를 보존한다. `USED/UNUSED/UNMAPPED` 판정은 source의 명시적 ID/ref 존재 여부에 따른다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:1420–1591, 1612–1669. +Stage 1의 16개 고정 입력과 signal family를 구분한다. manifest row의 `canonical`·`domain_signal`은 의미 입력, `compatibility_view`는 파일 무결성만 검사하는 입력이다. signal ID 하나로 deduplicate하지 않고 `(transaction, file_path, record_ordinal, signal_id)` 발생 단위를 보존한다. `USED/UNUSED/UNMAPPED` 판정은 source의 명시적 ID/ref 존재 여부에 따른다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:1420–1591, 1612–1669. -조건부 추가 입력은 release `/dependency_locks/stage1/contract_manifest_ref`가 지정한 `D/`와 `/completion_seal_ref`가 지정한 `U/`다. 현재는 contract path가 null이고 completion ref도 없다. 따라서 새 Stage 1 completion 파일의 상시 생성을 요구하는 구조로 해석하지 않는다. core resolver는 release-bound `path_overrides`만 인정하지만 실제 inline hydration는 먼저 release의 원래 fixed path를 읽으므로 relocation 실행 호환성에는 §8의 제한이 있다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:791–820, 4141–4161, 5700–5720, 6162–6183. +조건부 추가 입력은 release `/dependency_locks/stage1/contract_manifest_ref`가 지정한 `D/`와 `/completion_seal_ref`가 지정한 `U/`다. 현재는 contract path가 null이고 completion ref도 없다. 따라서 새 Stage 1 completion 파일의 상시 생성을 요구하는 구조로 해석하지 않는다. core resolver는 release-bound `path_overrides`만 인정하지만 실제 inline hydration는 먼저 release의 원래 fixed path를 읽으므로 relocation 실행 호환성에는 §8의 제한이 있다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:791–820, 4141–4161, 5700–5720, 6162–6183. ### 2.2 출력 파일과 소비자 -모든 persisted 출력은 canonical UTF-8 JSON이며 S2_00이 단독 writer다. `E`는 **최종 executable cluster 수**이다. 정상 branch는 아래 공통 4개 + context 7개 + slice E개, 즉 **11 + E개**다. diagnostic branch는 공통 4개 + technical diagnostic 1개, 정확히 5개다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:172–186, 5109–5243. +모든 persisted 출력은 canonical UTF-8 JSON이며 S2_00이 단독 writer다. `E`는 **최종 executable cluster 수**이다. 정상 branch는 아래 공통 4개 + context 7개 + slice E개, 즉 **11 + E개**다. diagnostic branch는 공통 4개 + technical diagnostic 1개, 정확히 5개다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:172–186, 5109–5243. | 출력 경로 | branch | 내용 및 직접/후속 소비 | |---|---|---| @@ -151,7 +158,7 @@ Stage 1의 16개 고정 입력과 signal family를 구분한다. manifest row의 `context_materialization_receipt`, `run_binding_receipt`, `hydration_stability_receipt`, `output_barrier`는 위 파일 안의 **embedded object**이며 별도 고정 파일이 아니다. `selected_legal_context_json`과 `cluster_case_payload_json`은 S2_00 output file이 아니라 **외부 orchestrator가 생성할 S2_10 item의 문자열 필드**다. -stdout에는 `stage2_s2_00_inner_receipt.v1` 한 객체만 출력한다. 성공은 `ok:true`, `SUCCEEDED` 또는 `DIAGNOSTIC_PUBLISHED`, route/run/hash와 `logical_publish_receipt`를 담는다. 예외는 `ok:false`, `FAILED_NO_BARRIER`, error와 exit 2다. stdout receipt를 `control/run_status.json`이나 최종 소송문안으로 오인하면 안 된다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:6018–6103. +stdout에는 `stage2_s2_00_inner_receipt.v1` 한 객체만 출력한다. 성공은 `ok:true`, `SUCCEEDED` 또는 `DIAGNOSTIC_PUBLISHED`, route/run/hash와 `logical_publish_receipt`를 담는다. 예외는 `ok:false`, `FAILED_NO_BARRIER`, error와 exit 2다. stdout receipt를 `control/run_status.json`이나 최종 소송문안으로 오인하면 안 된다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:6018–6103. ## 3. 작업용 자산과 정확한 배포 위치 @@ -177,11 +184,11 @@ stdout에는 `stage2_s2_00_inner_receipt.v1` 한 객체만 출력한다. 성공 | `R/release_ops/stage2_loader.py` 및 `R/release_ops/stage2_loader.txt` | Python/TXT | 과거 loader 보존본. S2_00 live 실행 dependency가 아님 | | `R/manifest/stage2_deterministic_admission_receipt.json` | JSON | 후속 구현과 공유하는 detached admission 증거. S2_00 inline에서 직접 검증하지 않으므로 외부 admission 책임과 구분 | -[근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:8–15, 194–208, 637–645, 5721–5753; [자산 inventory](S2_00_assets_v.2.md) §1.2·§3·§7; [workflow 계약](Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml) `orchestration_contract`. +[근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:8–15, 194–208, 637–645, 5721–5753; [자산 inventory](S2_00_assets_v.2.md) §1.2·§3·§7; [workflow 계약](Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml) `orchestration_contract`. ### 3.2 Stage 1 고정 배포 closure 55개 -각 경로는 `D/` 기준이며 모두 JSON이다. source-of-truth는 [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json) `/dependency_locks/stage1/concrete_paths`이다. 전체 Stage 1 YAML/runtime를 import하는 것이 아니라 **열거된 55개 source 계약 파일만** raw hash로 결속해 읽는다. `expected_concrete_path_count=55`이며 선언 개수·중복 경로·hash·strict JSON을 검사한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:4164–4242, 5670–5698. +각 경로는 `D/` 기준이며 모두 JSON이다. source-of-truth는 [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json) `/dependency_locks/stage1/concrete_paths`이다. 전체 Stage 1 YAML/runtime를 import하는 것이 아니라 **열거된 55개 source 계약 파일만** raw hash로 결속해 읽는다. `expected_concrete_path_count=55`이며 선언 개수·중복 경로·hash·strict JSON을 검사한다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:4164–4242, 5670–5698. | lock ID 범위 | exact path 또는 닫힌 전개 규칙 | 개수·사용 | |---|---|---| @@ -218,7 +225,7 @@ signal_manifest.schema.json ### 3.3 Stage 2 direct closure 49개 -현재 [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json) `/dependency_locks/stage2_direct`에는 아래 **49개**가 있다. inline hydration는 이 목록 전부를 읽고 raw hash 검증한다. selected context의 의미적 선택은 `/bundle/selected_context_refs`에 별도로 기록되며 현재 빈 배열이다. 따라서 “활성 profile만 원격 읽는다”와 “읽은 모든 profile을 LLM에게 준다”는 설명 모두 실제 코드와 다르다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:3283–3475, 5741–5753. +현재 [parent release](Default_Agent/Stage_2_Clean/manifest/stage2_release.json) `/dependency_locks/stage2_direct`에는 아래 **49개**가 있다. inline hydration는 이 목록 전부를 읽고 raw hash 검증한다. selected context의 의미적 선택은 `/bundle/selected_context_refs`에 별도로 기록되며 현재 빈 배열이다. 따라서 “활성 profile만 원격 읽는다”와 “읽은 모든 profile을 LLM에게 준다”는 설명 모두 실제 코드와 다르다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:3283–3475, 5741–5753. | path prefix | exact basename | 개수·역할 | |---|---|---| @@ -330,7 +337,7 @@ ACTIO-DEFENSE-MAP.yml ### 4.1 C05 검사 세부 목록 -`check_conservation`은 `BO_FACT_MULTISET`, `FACT_ID_SEQUENCE`, `CURRENT_V8_LEDGER_EXTENSIONS`, `LES_BO_JOIN`, `LES_DECLARED_ACTUAL_COUNT`, `LES_REVERSE_INDEX`, `EVIDENCE_REFERENCE_CONSERVATION`, `EVENT_REFERENCE_CONSERVATION`, `EVENT_DISPOSITION_CONSERVATION`, `FACT_LEDGER_WRITER_REPORT_CONNECTION`, `SIGNAL_FILE_ROW_CONSERVATION`, `SIGNAL_RECORD_OCCURRENCE_CONSERVATION`, `REVIEW_OCCURRENCE_CONSERVATION`을 구성한다. BO와 source_bo_id의 Counter 동일성, fact 배열의 `F-001..F-N` 순서·유일성, LES attach/reverse index, 참조 universe, writer-report 실측 재계산을 구별한다. 비교 자료가 없는 일부 검사에는 `UNEVALUABLE`이 가능하며 이를 PASS와 동일시하지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:2068–2436. +`check_conservation`은 `BO_FACT_MULTISET`, `FACT_ID_SEQUENCE`, `CURRENT_V8_LEDGER_EXTENSIONS`, `LES_BO_JOIN`, `LES_DECLARED_ACTUAL_COUNT`, `LES_REVERSE_INDEX`, `EVIDENCE_REFERENCE_CONSERVATION`, `EVENT_REFERENCE_CONSERVATION`, `EVENT_DISPOSITION_CONSERVATION`, `FACT_LEDGER_WRITER_REPORT_CONNECTION`, `SIGNAL_FILE_ROW_CONSERVATION`, `SIGNAL_RECORD_OCCURRENCE_CONSERVATION`, `REVIEW_OCCURRENCE_CONSERVATION`을 구성한다. BO와 source_bo_id의 Counter 동일성, fact 배열의 `F-001..F-N` 순서·유일성, LES attach/reverse index, 참조 universe, writer-report 실측 재계산을 구별한다. 비교 자료가 없는 일부 검사에는 `UNEVALUABLE`이 가능하며 이를 PASS와 동일시하지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:2068–2436. ### 4.2 cluster·slice·bundle의 서로 다른 의미 @@ -338,7 +345,7 @@ cluster는 청구권 또는 claim group의 확정값이 아니다. 같은 BO, LE slice는 cluster별 content/ref snapshot이다. projection당 최대 262,144 UTF-8 bytes, slice content 합계 최대 2,097,152 bytes이며 넘으면 잘라내지 않고 exception을 발생시킨다. 모든 projection은 source ID에 결속된 하나의 raw source hash를 요구한다. `slice_digest`는 그 필드를 넣기 전 body의 canonical digest, bundle의 `member_slices[].sha256`는 digest 필드까지 포함한 최종 slice body의 canonical digest다. 두 hash를 같은 값으로 취급하면 안 된다. -cohort는 현재 compiler에서 동일 release-selected context를 쓰는 valid slice 전체를 묶는다. cluster별 profile을 별도로 법률추론하여 골라주는 알고리즘이 아니다. missing slice는 별도의 non-executable cohort로 보존한다. selected context 허용 kind는 `ACTIVE_PROFILE`, `APPROVED_COMMON_AUTHORITY`, `LAW_VALUE_TOKEN`, `AUTHORITY_PROPOSITION`; 여기의 법률 context에 주민번호·이메일·한국 휴대전화 패턴이 있으면 PII 오류를 남긴다. 이 제한을 사건별 dynamic payload의 PII 전면 금지로 확대 해석하지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:2877–3279, 3283–3906. +cohort는 현재 compiler에서 동일 release-selected context를 쓰는 valid slice 전체를 묶는다. cluster별 profile을 별도로 법률추론하여 골라주는 알고리즘이 아니다. missing slice는 별도의 non-executable cohort로 보존한다. selected context 허용 kind는 `ACTIVE_PROFILE`, `APPROVED_COMMON_AUTHORITY`, `LAW_VALUE_TOKEN`, `AUTHORITY_PROPOSITION`; 여기의 법률 context에 주민번호·이메일·한국 휴대전화 패턴이 있으면 PII 오류를 남긴다. 이 제한을 사건별 dynamic payload의 PII 전면 금지로 확대 해석하지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:2877–3279, 3283–3906. ## 5. upstream–downstream 자료 의존 @@ -354,13 +361,13 @@ cohort는 현재 compiler에서 동일 release-selected context를 쓰는 valid | S2_00 → S2_40 status-only | 법률판단 입력이 성립하지 않는 run의 상태 보존 | 정확히 status·technical_diagnostic·manifest·intake·base issue 5개. 청구취지·청구원인 생성을 우회 | | S2_00 → S2_40 정상 검증 | 최종 문안이 원래 자료·run에 연결되는지 대조 | S2_00 barrier/manifest/source digest를 상류 검증 기준으로 사용. 최종 상태 writer는 S2_40 | -[근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:211–227, 4801–5243; [SOW](S2_00_SOW_v.2.md) §8.3; [S2_10 Agent](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_10.yml), [S2_40 Agent](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml)는 후단 소비 명세의 위치이며 해당 전체 분석은 각각의 별도 작업분석서를 참조한다. +[근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:211–227, 4801–5243; [SOW](S2_00_SOW_v.2.md) §8.3; [S2_10 Agent](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_10.yml), [S2_40 Agent](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_40.yml)는 후단 소비 명세의 위치이며 해당 전체 분석은 각각의 별도 작업분석서를 참조한다. ## 6. 결정성·발행·실패의 의미 -`input_set_digest`는 fixed snapshot과 signal/deployment closure의 logical ID/path/raw hash로 계산한다. `run_binding_digest`는 `input_set_digest + parent release raw hash + ALGORITHM_SEMANTIC_DIGEST + release_class`의 canonical JSON digest다. `run_id=S2RUN-`, output root는 `by-binding/`로 파생한다. algorithm digest는 `ALGORITHM_VERSION` 문자열에 namespace를 붙여 해시한 의미 버전 digest이며 **Python 전체 source hash와는 다르다**. actual source hash는 projection/receipt 체계가 별도로 관리한다. attempt ID는 canonical binding에 포함되지 않는다. request ID와 user/workspace hash는 receipt에 보존되지만 binding formula에는 포함되지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:79–82, 4544–4612. +`input_set_digest`는 fixed snapshot과 signal/deployment closure의 logical ID/path/raw hash로 계산한다. `run_binding_digest`는 `input_set_digest + parent release raw hash + ALGORITHM_SEMANTIC_DIGEST + release_class`의 canonical JSON digest다. `run_id=S2RUN-`, output root는 `by-binding/`로 파생한다. algorithm digest는 `ALGORITHM_VERSION` 문자열에 namespace를 붙여 해시한 의미 버전 digest이며 **Python 전체 source hash와는 다르다**. actual source hash는 projection/receipt 체계가 별도로 관리한다. attempt ID는 canonical binding에 포함되지 않는다. request ID와 user/workspace hash는 receipt에 보존되지만 binding formula에는 포함되지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:79–82, 4544–4612. -로컬 publish는 전 출력 schema 검사 → non-status write/fsync → status에 exact artifact list/digest 삽입 → status write/fsync → staging directory rename 순서다. 원격은 localdocs `write_binary_file(overwrite:true)`와 매 파일 read-back을 사용하고 barrier를 마지막에 쓴다. 원격 directory rename·OS fsync·단일 transaction이 보장된다는 뜻은 아니다. 기존 remote barrier가 있으면 run binding과 **status 전체 bytes** 및 모든 artifact bytes까지 동일해야 idempotent success다. 다른 request ID가 같은 input binding을 공유하면 status bytes가 달라질 수 있으므로 “input이 같으면 request ID와 무관하게 무조건 재사용”이라고 쓰지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:4015–4108, 5934–6008. +로컬 publish는 전 출력 schema 검사 → non-status write/fsync → status에 exact artifact list/digest 삽입 → status write/fsync → staging directory rename 순서다. 원격은 localdocs `write_binary_file(overwrite:true)`와 매 파일 read-back을 사용하고 barrier를 마지막에 쓴다. 원격 directory rename·OS fsync·단일 transaction이 보장된다는 뜻은 아니다. 기존 remote barrier가 있으면 run binding과 **status 전체 bytes** 및 모든 artifact bytes까지 동일해야 idempotent success다. 다른 request ID가 같은 input binding을 공유하면 status bytes가 달라질 수 있으므로 “input이 같으면 request ID와 무관하게 무조건 재사용”이라고 쓰지 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:4015–4108, 5934–6008. | 실제 조건 | 구현 결과 | |---|---| @@ -371,7 +378,7 @@ cohort는 현재 compiler에서 동일 release-selected context를 쓰는 valid | hydration/transport/예외 등 core 정상 조립 이전 또는 도중 fatal 오류 | `FAILED_NO_BARRIER`, exit 2. diagnostic 5파일 자동 발행이 아님 | | `release_class=DEV_FIXTURE_RELEASE`로 `execute_ingress` 진입 | `DEV_FIXTURE_REAL_RUN_FORBIDDEN`; STRUCTURAL_FIXTURE는 별개 bundle mode | -core diagnostic code 집합은 `RELEASE_SOURCE_CONTRACT_MISSING`, `RELEASE_SOURCE_PATH_MISMATCH`, `RAW_HASH_MISMATCH`, `SCHEMA_HASH_MISMATCH`, `SCHEMA_ID_MISMATCH`, `RUN_IDENTITY_CONFLICT`, `TRANSACTION_IDENTITY_CONFLICT`, `BO_FACT_CONSERVATION_FAILED`, `FACT_ID_CONSERVATION_FAILED`, `CURRENT_V8_LEDGER_EXTENSION_MISSING`다. 모든 ERROR를 동일하게 전역 차단하지 않으며 모든 exception을 status-only로 회복하지도 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml), Y:4770–4830, 6087–6103. +core diagnostic code 집합은 `RELEASE_SOURCE_CONTRACT_MISSING`, `RELEASE_SOURCE_PATH_MISMATCH`, `RAW_HASH_MISMATCH`, `SCHEMA_HASH_MISMATCH`, `SCHEMA_ID_MISMATCH`, `RUN_IDENTITY_CONFLICT`, `TRANSACTION_IDENTITY_CONFLICT`, `BO_FACT_CONSERVATION_FAILED`, `FACT_ID_CONSERVATION_FAILED`, `CURRENT_V8_LEDGER_EXTENSION_MISSING`다. 모든 ERROR를 동일하게 전역 차단하지 않으며 모든 exception을 status-only로 회복하지도 않는다. [근거: 배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml), Y:4770–4830, 6087–6103. `FAILED_NO_BARRIER`는 반환 label이지 실제 barrier가 없다는 확인 결과가 아니다. Y:5989의 status write 뒤 5990의 read-back 실패, 또는 publish 성공 후 Y:6084–6086의 localdocs.close 실패도 generic catch에서 이 label을 반환한다. 이미 쓴 non-status 파일과 barrier를 rollback하지 않으므로 외부 실행 관리자는 실제 상태/hash를 재확인해야 한다. diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_IO_info.md b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_IO_info.md index 23a492aa..802739d9 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_IO_info.md +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_00_IO_info.md @@ -1,8 +1,20 @@ # Stage_2_S2_00.yml 단계별 Input / Output 파일 정보 +## 2026-10-01 현행 IO 변경 + +아래 표와 `Y:행번호`는 [보존된 기존 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml)의 정적 분석이다. [현행 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml)의 Agent DAG는 `IN → Task_S2_00_prepare_request → Task_S2_00_deterministic_ingress → OUT`이다. + +| 단계 | 입력 파일·형식·source folder | 출력 파일·형식·저장 folder | 상태 | +|---|---|---|---| +| `Task_S2_00_prepare_request` | 고정 입력 파일 없음. 호출자가 공급하는 네 문자열 `request_id`, `attempt_id`, `stage1_run_root_ref`, `stage1_deployment_root_ref` 및 인증된 localdocs workspace 세션 | `s2_00_request.json` · canonical UTF-8 JSON, 정확히 6필드 · `W/stage2_control/` | 함수의 생성·검증·write/read-back은 offline 시험 완료. backend 인자 전달·성공 게이트·workspace 직렬화는 미검증이며 직접 `run_code` 실행은 fail closed | +| `Task_S2_00_deterministic_ingress` | `W/stage2_control/s2_00_request.json` 및 아래 §3의 기존 Stage 1·release 입력 | 아래 §4의 기존 `O/` 정상 11+E 또는 diagnostic 5개 JSON | 기존 ingress 검증과 두 read-pass 유지. 실사건 실행은 미검증 | + +`W/`는 동일 user/workspace의 localdocs 논리 root다. 첫 task의 성공 뒤에도 다른 실행이 고정 request 경로를 덮어쓰지 못한다는 보장은 backend 통합 전까지 없다. 아래 “외부 orchestrator가 request를 공급”이라는 producer 표기는 보존본 기준이며, 현행 코드상 producer는 새 prepare task다. + + ## 1. 범위·기준 및 경로 표기 -작성 기준일: 2026-09-30. 사용자 지정 [Stage_2_00_Analysis_v1.md](Stage_2_00_Analysis_v1.md)의 DAG·IO·자산 분석을 기준으로, [배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00.yml)과 해당 YAML이 참조하는 release/module manifest를 대조하였다. main 폴더 바로 아래의 동명 YAML은 분석 대상이 아니다. `Y:행번호`는 배포 YAML의 행번호이다. +작성 기준일: 2026-09-30. 사용자 지정 [Stage_2_00_Analysis_v1.md](Stage_2_00_Analysis_v1.md)의 DAG·IO·자산 분석을 기준으로, [배포 YAML](Default_Agent/Stage_2_Clean/agent_scripts/Stage_2_S2_00_outdated_10_01.yml)과 해당 YAML이 참조하는 release/module manifest를 대조하였다. main 폴더 바로 아래의 동명 YAML은 분석 대상이 아니다. `Y:행번호`는 배포 YAML의 행번호이다. 이 문서는 **파일 계약에 대한 정적 분석**이다. 사건 run이나 MCP 실행을 수행하여 파일 생성 성공을 확인한 문서가 아니다. 현재 release는 `DEV_FIXTURE_RELEASE / DRAFT_NOT_EXECUTABLE`이며 core의 DEV guard가 실제 run을 거절한다. 아래 출력은 해당 실행 경로가 정상적으로 완료되는 경우의 코드상 산출물이다. diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_00_v.2.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_00_v.2.yml index b8c468d2..df39cc88 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_00_v.2.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_00_v.2.yml @@ -12,11 +12,12 @@ Agent: release_ref: Default_Agent/Stage_2_Clean/manifest/stage2_release.json workflow_contract_ref: Default_Agent/Stage_2_Clean/workflows/S2_00_stage1_ingress_normalize_and_bundle_compile.yml deployment_binding_ref: Default_Agent/Stage_2_Clean/deployment/stage2_code_executor_binding.yml - implementation_status: S2_00_CODE_AND_FIXTURE_OFFLINE_VERIFIED_S2_10_HYBRID_REIMPLEMENTATION_AND_RESEAL_PENDING_LIVE_ADMISSION_PENDING + implementation_status: S2_00_PREPARE_OFFLINE_VERIFIED_BACKEND_ARGUMENT_GATE_AND_SERIALIZATION_UNVERIFIED_LIVE_ADMISSION_PENDING Stages: - name: S2_00 description: >- - 단일 Code Executor 호출 안에서 C00, C05, C10, C15를 순차 실행하고 + 첫 Code Executor task에서 고정 request를 준비하고, 다음 ingress + task의 한 호출 안에서 C00, C05, C10, C15를 순차 실행한다. localdocs binary IO와 status-last 논리 배리어로 결과를 발행한다. prevs: [] nexts: [] @@ -29,6 +30,254 @@ Agent: type: streamable-http url: https://code-executor.mcp.eroomai.com/mcp tasks: + - task_name: Task_S2_00_prepare_request + description: >- + 네 외부 문자열 인자 request_id, attempt_id, stage1_run_root_ref, + stage1_deployment_root_ref를 검증하고 고정 localdocs request 경로에 + 저장·read-back한다. Backend 인자 결속 및 성공 게이트는 미검증이며 + 인자가 결속되지 않은 직접 실행은 실패로 종료한다. + mcp: code-executor + tool_name: run_code + parameters: + language: python + requirements: "httpx==0.28.1" + network: agent-network + timeout: 300 + code: |- + #!/usr/bin/env python3 + """Prepare the fixed S2_00 control request from four explicit caller values. + + The backend argument-delivery contract is not bound. Direct execution fails + closed; callers must invoke ``prepare_request`` with the four named values. + """ + + from __future__ import annotations + + import base64 + import hashlib + import json + from pathlib import PurePosixPath + import re + import sys + import unicodedata + from typing import Any, Mapping + + + REQUEST_PATH = "stage2_control/s2_00_request.json" + LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" + MCP_PROTOCOL_VERSION = "2025-03-26" + INLINE_USER_HASH = "{{__user_hash__}}" + INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" + REQUEST_KEYS = frozenset({ + "schema_version", "workflow_id", "request_id", "attempt_id", + "stage1_run_root_ref", "stage1_deployment_root_ref", + }) + ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z") + + + class PrepareError(ValueError): + def __init__(self, code: str, message: str) -> None: + super().__init__(message) + self.code = code + + + def canonical_json_bytes(value: Any) -> bytes: + return (json.dumps(value, ensure_ascii=False, allow_nan=False, + sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8") + + + def _relative_path(value: str, *, code: str) -> str: + if not isinstance(value, str) or not value or "\x00" in value or "\\" in value: + raise PrepareError(code, "logical path is empty or malformed") + if unicodedata.normalize("NFC", value) != value: + raise PrepareError(code, "logical path must already be NFC") + path = PurePosixPath(value) + if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts): + raise PrepareError(code, "logical path must be a contained relative path") + rendered = path.as_posix() + if rendered != value: + raise PrepareError(code, "logical path is not canonical") + return rendered + + + def build_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + ) -> bytes: + """Return the exact six-field canonical request; do not access localdocs.""" + if not isinstance(request_id, str) or ID_RE.fullmatch(request_id) is None: + raise PrepareError("REQUEST_ID_INVALID", "request_id contains forbidden characters") + if not isinstance(attempt_id, str) or ID_RE.fullmatch(attempt_id) is None: + raise PrepareError("ATTEMPT_ID_INVALID", "attempt_id contains forbidden characters") + request = { + "schema_version": "stage2_s2_00_execution_request.v1", + "workflow_id": "S2_00", + "request_id": request_id, + "attempt_id": attempt_id, + "stage1_run_root_ref": _relative_path( + stage1_run_root_ref, code="STAGE1_RUN_ROOT_REF_INVALID"), + "stage1_deployment_root_ref": _relative_path( + stage1_deployment_root_ref, code="STAGE1_DEPLOYMENT_ROOT_REF_INVALID"), + } + if set(request) != REQUEST_KEYS: + raise PrepareError("RUN_REQUEST_CLOSED_SHAPE", "request field set drifted") + return canonical_json_bytes(request) + + + class LocaldocsSession: + """Small localdocs JSON-RPC session with verified binary write/read-back.""" + + def __init__(self, user_hash: str, workspace_hash: str, *, client: Any = None) -> None: + for name, value in (("user_hash", user_hash), ("workspace_hash", workspace_hash)): + if not isinstance(value, str) or re.fullmatch(r"[a-f0-9]{64}", value) is None: + raise PrepareError("CONTEXT_HASH_INVALID", f"{name} is not a SHA-256 digest") + self.user_hash = user_hash + self.workspace_hash = workspace_hash + if client is None: + try: + import httpx + except ImportError as exc: + raise PrepareError("HTTPX_UNAVAILABLE", "httpx==0.28.1 is required") from exc + client = httpx.Client(timeout=60) + self.client = client + self.headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"} + self.session_id: str | None = None + self.next_id = 10 + self.initialized = False + + def close(self) -> None: + self.client.close() + + def _post(self, body: Mapping[str, Any], expected_id: int | None) -> Mapping[str, Any] | None: + try: + response = self.client.post(LOCALDOCS_URL, json=dict(body), headers=dict(self.headers)) + response.raise_for_status() + except Exception as exc: + raise PrepareError("MCP_TRANSPORT_ERROR", "localdocs transport failed") from exc + session_id = response.headers.get("mcp-session-id") + if session_id: + if self.session_id is None and expected_id == 1: + self.session_id = session_id + elif session_id != self.session_id: + raise PrepareError("MCP_SESSION_ID_CHANGED", "localdocs session changed") + self.headers["mcp-session-id"] = session_id + if expected_id is None: + return None + try: + payload = response.json() + except Exception as exc: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response is not JSON") from exc + if not isinstance(payload, dict) or payload.get("jsonrpc") != "2.0" or payload.get("id") != expected_id: + raise PrepareError("MCP_RESPONSE_INVALID", "localdocs response ID or shape mismatch") + if "error" in payload or not isinstance(payload.get("result"), dict): + raise PrepareError("MCP_TOOL_ERROR", "localdocs returned an error") + return payload["result"] + + def initialize(self) -> None: + response = self._post({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { + "protocolVersion": MCP_PROTOCOL_VERSION, "capabilities": {}, "clientInfo": { + "name": "liti-s2-00-prepare", "version": "1.0.0", + "user_id": self.user_hash, "workspace_id": self.workspace_hash, + }}}, 1) + if response is None or response.get("protocolVersion") != MCP_PROTOCOL_VERSION or self.session_id is None: + raise PrepareError("MCP_INITIALIZE_INVALID", "localdocs initialization failed") + self._post({"jsonrpc": "2.0", "method": "notifications/initialized"}, None) + self.initialized = True + + def call(self, name: str, arguments: Mapping[str, Any]) -> Mapping[str, Any]: + if not self.initialized: + raise PrepareError("MCP_NOT_INITIALIZED", "localdocs is not initialized") + message_id = self.next_id + self.next_id += 1 + result = self._post({"jsonrpc": "2.0", "id": message_id, "method": "tools/call", + "params": {"name": name, "arguments": dict(arguments)}}, message_id) + if result is None or result.get("isError") is True: + raise PrepareError("MCP_TOOL_ERROR", f"localdocs {name} failed") + return result + + def read_binary(self, logical_path: str) -> bytes: + path = _relative_path(logical_path, code="LOCALDOCS_READ_PATH_INVALID") + result = self.call("read_binary_doc", {"doc_name": path}) + content = result.get("content") + if not isinstance(content, list) or len(content) != 1 or not isinstance(content[0], dict) or content[0].get("type") != "text": + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary response") + text = content[0].get("text") + if not isinstance(text, str): + raise PrepareError("LOCALDOCS_READ_SHAPE", "missing binary envelope") + try: + envelope = json.loads(text) + if isinstance(envelope, dict) and "results" in envelope: + rows = envelope["results"] + if not isinstance(rows, list) or len(rows) != 1 or not isinstance(rows[0], dict): + raise ValueError("binary result cardinality mismatch") + inner = rows[0].get("content", rows[0].get("text")) + envelope = json.loads(inner) if isinstance(inner, str) else inner + encoded = envelope["content_base64"] + if not isinstance(encoded, str): + raise ValueError("binary content is not base64") + payload = base64.b64decode(encoded, validate=True) + size = envelope.get("byte_length", envelope.get("size")) + if size is not None and (not isinstance(size, int) or size != len(payload)): + raise ValueError("binary size mismatch") + digest = envelope.get("sha256") + if digest is not None and digest != hashlib.sha256(payload).hexdigest(): + raise ValueError("binary hash mismatch") + return payload + except (ValueError, KeyError, TypeError, base64.binascii.Error) as exc: + raise PrepareError("LOCALDOCS_READ_SHAPE", "invalid binary envelope") from exc + + def write_binary_verified(self, logical_path: str, payload: bytes) -> str: + path = _relative_path(logical_path, code="LOCALDOCS_WRITE_PATH_INVALID") + if path != REQUEST_PATH: + raise PrepareError("LOCALDOCS_WRITE_PATH_INVALID", "prepare may write only the fixed request path") + result = self.call("write_binary_file", { + "path": path, "content_base64": base64.b64encode(payload).decode("ascii"), "overwrite": True, + }) + if not isinstance(result.get("content"), list) or result.get("isError") is True: + raise PrepareError("LOCALDOCS_WRITE_FAILED", "localdocs did not acknowledge write") + observed = self.read_binary(path) + if observed != payload: + raise PrepareError("LOCALDOCS_WRITE_READBACK_MISMATCH", "request read-back differs") + return hashlib.sha256(observed).hexdigest() + + + def prepare_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, + *, + localdocs: Any = None, + ) -> dict[str, Any]: + """Validate, write, read back, and close an authenticated localdocs session.""" + payload = build_request(request_id, attempt_id, stage1_run_root_ref, stage1_deployment_root_ref) + session = localdocs if localdocs is not None else LocaldocsSession(INLINE_USER_HASH, INLINE_WORKSPACE_HASH) + failure: Exception | None = None + digest: str | None = None + try: + session.initialize() + digest = session.write_binary_verified(REQUEST_PATH, payload) + except Exception as exc: + failure = exc + try: + session.close() + except Exception as exc: + if failure is None: + failure = PrepareError("LOCALDOCS_CLOSE_FAILED", "localdocs session close failed") + failure.__cause__ = exc + if failure is not None: + raise failure + return {"ok": True, "workflow_id": "S2_00", "path": REQUEST_PATH, + "request_sha256": digest} + + + if __name__ == "__main__": + sys.stdout.buffer.write(canonical_json_bytes({ + "ok": False, "error": {"code": "PREPARE_ARGUMENT_BINDING_UNVERIFIED", + "message": "four caller values must be bound by the backend"}})) + raise SystemExit(2) - task_name: Task_S2_00_deterministic_ingress description: >- 고정 request와 release를 hydration하고 S2_00 pure core를 실행한 뒤 @@ -192,7 +441,7 @@ Agent: # literal placeholders in the offline parity mirror and its unit tests. INLINE_USER_HASH = "{{__user_hash__}}" INLINE_WORKSPACE_HASH = "{{__workspace_hash__}}" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" INLINE_REQUEST_PATH = "stage2_control/s2_00_request.json" INLINE_STAGE2_ASSET_ROOT = "Default_Agent/Stage_2_Clean" INLINE_STAGE2_RELEASE_PATH = ( @@ -6235,13 +6484,18 @@ Agent: task_procedure: IN: nexts: - - Task_S2_00_deterministic_ingress + - Task_S2_00_prepare_request wait_until: [] + Task_S2_00_prepare_request: + nexts: + - Task_S2_00_deterministic_ingress + wait_until: + - IN Task_S2_00_deterministic_ingress: nexts: - OUT wait_until: - - IN + - Task_S2_00_prepare_request OUT: nexts: [] wait_until: diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_20.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_20.yml index eb547a7e..b5b3bdeb 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_20.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_20.yml @@ -71,7 +71,7 @@ Agent: WORKFLOW_ID = "S2_20" ALGORITHM_VERSION = "s2_20_relief_plan/1.0.0" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" WEAVIATE_MCP_URL = "https://weaviate.eroomai.com/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_30.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_30.yml index 55c36d46..85d73661 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_30.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_30.yml @@ -73,7 +73,7 @@ Agent: from typing import Any, Mapping - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_40.yml b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_40.yml index 57d65722..366d3c1f 100644 --- a/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_40.yml +++ b/Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/Stage_2_S2_40.yml @@ -68,7 +68,7 @@ Agent: WORKFLOW_ID = "S2_40" ALGORITHM_VERSION = "s2_40_finalizer/1.0.0" - EXPECTED_STAGE2_RELEASE_SHA256 = "9fa85bb94c5f14f675dcdaa0cf94d06745b21675d97797539ffc14015dcc9f53" + EXPECTED_STAGE2_RELEASE_SHA256 = "2363f1166ee8a3ea2b38350cde61fccfc9852a413c6b9f14a6ed6606af15a590" LOCALDOCS_URL = "http://mcp-localdocs:8012/mcp" MCP_PROTOCOL_VERSION = "2025-03-26" INLINE_USER_HASH = "{{__user_hash__}}" diff --git a/Case_02_Comparison_Research/plans/s2-00-request-preparation_v2.md b/Case_02_Comparison_Research/plans/s2-00-request-preparation_v2.md new file mode 100644 index 00000000..f450e5c1 --- /dev/null +++ b/Case_02_Comparison_Research/plans/s2-00-request-preparation_v2.md @@ -0,0 +1,157 @@ +# S2_00 request 생성·저장 계획 v2 + +작성일: 2026-10-01. 상태: **계획 작성 완료 / 구현 미착수**. [v1](s2-00-request-preparation_v1.md)의 두 task 구상과 기존 request 계약을 계승한다. 이 문서는 `s2_00_request.json`의 생성 코드를 먼저 구현·시험할 수 있도록 작업 순서를 개정한 계획이다. + +## Objective + +`Stage_2_S2_00.yml` 작업명세서의 맨 앞에 `Task_S2_00_prepare_request`를 배치한다. 이 작업의 핵심 함수를 네 외부 인자를 받는 명시적 인터페이스로 구현하여, 기존 6필드 검증·canonical JSON 직렬화·localdocs binary 저장/read-back 방식으로 `stage2_control/s2_00_request.json`을 만든다. 함수와 task의 offline 검증은 backend의 인자 주입·스케줄링·직렬화 구현 정보가 없어도 진행한다. 실제 운영 연결은 확인된 backend 인터페이스에만 결속한다. + +```text +IN → Task_S2_00_prepare_request → Task_S2_00_deterministic_ingress → OUT + 4개 인자 검증 기존 request 읽기·2회 hydration + 6필드 JSON 구성 + localdocs 저장·read-back +``` + +위 DAG는 작업명세서에서 의도하는 순서다. `nexts`·`wait_until` 선언만으로 prepare 실패 시 ingress가 실제로 차단되거나 두 실행 사이의 파일 경합이 해소되었다고 주장하지 않는다. + +## Deliverables + +1. 네 인자를 받아 정확히 6필드 request bytes를 생성·검증하는 작은 함수와, 검증된 bytes를 고정 경로에 write/read-back하는 준비 함수. +2. 준비 task를 기존 ingress 앞에 둔 authoring YAML 및 빌더로 생성한 배포 YAML, 두 task의 code mirror·빌드 receipt. +3. 변경으로 실제 영향을 받는 workflow·executor binding·schema·manifest/release·hash 참조와 정적·offline 시험. +4. 구현 후 실제 상태에 맞춘 S2_00 분석서·IO 문서. 운영 연결이 검증되지 않았다면 그 상태를 명시한다. + +## Scope and Non-Scope + +현재 request의 **6필드와 고정 경로를 유지**한다. 기존 C00–C15의 자료 처리 및 정상/diagnostic 출력 계약은 변경하지 않는다. 새 request receipt 파일, 범용 실행 프레임워크, 임의 backend 변수·템플릿, 독립 잠금 서비스를 생성 코드의 선행 조건으로 두지 않는다. 기존 DEV release 제한이나 다른 Stage 2 결함의 해소는 이 작업의 완료 기준에 포함하지 않는다. + +이 계획의 1차 완료는 **생성·검증·저장 코드와 offline 시험**이다. 같은 YAML이 실제 사건 run에서 네 인자를 어떻게 받는지, 실패 시 다음 task 호출을 어떻게 막는지, 고정 request 경로의 동시 쓰기를 어떻게 막는지는 별도의 운영 통합 완료 조건이다. 이 구분 때문에 운영 정보가 없어도 코드 작성을 중단하지 않으며, offline 결과를 live 실행 성공으로 표시하지 않는다. + +## Known Inputs + +`M/ = Case_02_Comparison_Research/YAML_Prompts/2. Stage_2/`, `R/ = M/Default_Agent/Stage_2_Clean/`, `W/ = localdocs가 결속한 논리 workspace root`. + +- 정본: `M/Stage_2_S2_00_v.2.yml`; 현재 배포본: `R/agent_scripts/Stage_2_S2_00.yml`. +- 기존 request 소비 코드는 `stage2_control/s2_00_request.json`을 먼저 읽고, 정확히 6필드·ID·canonical 상대경로를 검증하며, hydration에서 같은 원격 경로의 bytes를 두 번 비교한다. +- 기존 runtime의 `canonical_json_bytes`, `_inline_validate_request`, `_inline_relative_path`, `write_binary_verified`가 각각 직렬화·검증·경로 검증·write/read-back 기준이다. 독립 task가 runtime `.py`를 외부 import한다고 가정하지 않는다. +- 현재 S2_00 빌더는 정확히 1 task 및 1 code pointer를 요구하고 executor binding은 결과 root 쓰기를 명시한다. 준비 task 추가 시 관련 계약 변경이 필요하다. +- backend의 네 인자 주입·성공 조건·workspace 직렬화 구현은 현재 확인되지 않았다. **코드 구현의 선행 차단 조건이 아니라 운영 연결의 미확인 항목**으로 둔다. + +## Material Assumptions + +- 네 값은 호출자가 지정한 문자열이며, 함수는 위치를 추측하거나 사건 폴더를 검색하지 않는다. +- `request_id`와 `attempt_id`는 기존 정규식에 맞고, 두 root ref는 NFC canonical workspace 상대경로여야 한다. 문법 검증과 실제 Stage 1 run 선택·접근 권한 검증은 구별한다. +- `write_binary_verified`의 성공은 그 호출 직후 read-back한 bytes의 일치를 뜻한다. 다른 실행의 동시 덮어쓰기까지 막는 보장은 아니다. +- 독립 task 사이에 메모리 공유가 있다고 가정하지 않는다. 같은 인자를 후행 task에 공급할 수 있음이 확인되면 v1의 전체 expected-bytes 비교를 적용한다. 확인 전에는 그 비교를 운영상 완료했다고 주장하지 않는다. + +## Questions That Could Change the Outcome + +다음 사항은 **운영 연결 단계에서만** 확인한다: 실제 backend가 네 값을 task에 전달하는 형식, 실패한 prepare 이후 ingress 시작을 막는 판정 방식, 동일 workspace의 고정 경로를 보호하는 직렬화·취소 처리. 코드 작성 시 이 형식을 추측한 placeholder를 executable로 넣지 않는다. 운영 기능이 없다면 필요한 backend 변경을 기록하고 생성 코드·offline 검증 결과와 분리한다. + +## Workstreams and Dependencies + +### 1. 기존 계약에 맞는 순수 request 생성 함수 + +```python +def build_request( + request_id: str, + attempt_id: str, + stage1_run_root_ref: str, + stage1_deployment_root_ref: str, +) -> bytes: + # 설명용 서명: 실제 함수명과 코드는 구현 시 기존 inline 규약에 맞춘다. + ... +``` + +1. 네 인자의 타입·값을 검사한다. ID는 `[A-Za-z0-9][A-Za-z0-9._-]{0,127}`를, root ref는 기존 `_inline_relative_path`의 NFC·상대경로·구성요소 규칙을 따른다. +2. `schema_version = "stage2_s2_00_execution_request.v1"`, `workflow_id = "S2_00"`을 코드 상수로 넣어 **정확히 여섯 필드**를 구성한다. caller가 추가 키를 request에 넣는 우회 경로를 만들지 않는다. +3. 기존 `canonical_json_bytes`와 동일한 규칙으로 UTF-8 bytes를 만든다. 기존 `_inline_validate_request`의 수용 여부와 byte 직렬화 규칙을 대조한다. 별도 schema framework를 만들지 않는다. +4. 이 함수는 localdocs를 호출하지 않아 정상·오류 입력의 단위 시험이 가능해야 한다. 함수가 root의 실재나 권한을 확인했다고 표시하지 않는다. + +### 2. localdocs 저장 함수와 선행 task 배치 + +- 준비 함수는 위 bytes를 받아 인증된 localdocs 세션에서 **고정 경로** `stage2_control/s2_00_request.json`에 `write_binary_verified` 방식으로 쓴다. write 응답과 같은 경로의 read-back bytes가 일치해야 성공한다. +- session 초기화·종료 및 오류 응답은 기존 S2_00 inline MCP 패턴을 따른다. 종료 실패까지 성공으로 표시하지 않는다. 독립 task 코드가 필요한 helper를 포함할 때 기존 구현과 parity를 검사한다. +- 새 task를 authoring YAML의 첫 task로 놓고 `task_procedure`를 `IN → prepare → ingress → OUT`으로 지정한다. prepare의 입력 계약에는 네 문자열 인자와 localdocs 세션을 명시한다. **실제 backend가 지원하는 전달 문법을 확인하기 전에는 임의 `run_code` parameter·환경변수·치환 토큰을 작성하지 않는다.** +- prepare는 성공 시 최소한의 기계 판독 가능 성공/실패 결과를 내도록 설계한다. 신규 저장 receipt나 별도 버전 schema는 만들지 않는다. 오류·read-back 불일치·session 종료 실패 시 실패를 반환한다. +- 기존 ingress는 request의 strict 검증·두 read-pass를 유지한다. 같은 네 인자를 후행에도 공급하는 연결이 확인되면 첫 읽기의 전체 bytes를 재구성한 expected bytes와 비교하는 검사를 추가한다. 이 연결이 없는 offline 단계에서는 준비 함수와 ingress validator의 호환성을 직접 시험하고, 런타임의 동일 요청 소비는 미검증으로 표시한다. + +### 3. 변경된 task 구조에 필요한 자산만 갱신 + +| 자산 | 필요한 변경 | +|---|---| +| `M/Stage_2_S2_00_v.2.yml` | 준비 task를 맨 앞에 배치하고 순서·입력·성공/실패 계약 기록 | +| `R/offline_build/build_s2_00_inline_projection.py/.txt` | 정확한 두 task ID·순서·code pointer 검증; `tasks[0]`이 ingress라는 전제 제거 | +| `R/agent_scripts/Stage_2_S2_00.yml` 및 runtime `.py/.txt` mirror | 정본으로부터 배포본과 두 task의 code mirror 재생성·parity 확인. 기존 파일 덮어쓰기 전 원본 보존 조건 적용 | +| `R/manifest/s2_00_inline_code_receipt.json` | 두 code pointer·hash와 task DAG 결속; 빌드 receipt에만 반영, 새 실행 receipt 파일 없음 | +| workflow·executor binding | 준비 단계의 네 인자 계약·고정 request 쓰기 경로와 기존 ingress 결과 경로를 구별. 실제 backend 강제 여부는 별도 표시 | +| 관련 schema·module/release/hash | task 구조·참조가 실제 바뀐 파일만 갱신하고 기존 6필드 request schema는 유지. hash 참조 순서를 확인하여 순환 결속을 만들지 않음 | +| `M/Stage_2_00_Analysis_v1.md`, `M/Stage_2_00_IO_info.md` | 구현·검증 후 선행 task와 생성 시점, offline/운영 상태의 경계를 반영 | + +기존 `Stage_2_S2_00_outdated_9_09.yml` 보존본과 원본 v1 계획은 변경하지 않는다. 새 task를 추가했으므로 기존 단일 task 빌드 검사를 끄거나 결과만 수동 수정하는 방식은 사용하지 않는다. + +### 4. offline 시험과 운영 연결의 순서 + +1. 순수 함수의 정상·오류 입력과 기존 validator 호환성을 시험한다. +2. fake localdocs 또는 격리 fixture에서 write/read-back 일치, 쓰기·읽기·session 종료 실패, 고정 경로 외 쓰기 방지를 시험한다. 실패 결과 뒤 ingress를 호출하지 않는 **로컬 호출 흐름**도 확인한다. +3. builder `--check`, 두 code mirror/hash, 변경 schema·release 참조, 기존 S2_00 정상/diagnostic fixture 회귀를 검증한다. 같은 입력으로 반복 빌드해 bytes 차이가 없는지 확인한다. +4. 실제 backend 인자 전달·실패 차단·workspace 직렬화가 확인되면 YAML의 실행 연결을 결속하고, 동일 요청 소비·경쟁·취소 시험을 수행한다. 이 단계가 끝나기 전에는 실제 S2_00 run 적격성을 주장하지 않는다. + +## Source and Tool Plan + +현재 authoring YAML·배포 코드·request schema·builder·binding을 1차 근거로 사용한다. 구현의 초기 시험은 직접 함수 호출과 격리된 localdocs 대역으로 진행한다. 운영 연결에 필요한 정보만 실제 backend 코드·명세에서 확인한다. 이 문서 작성 자체는 코드를 실행·수정하지 않는다. + +## Validation Plan + +| 검증 | 통과 기준 | 상태 구분 | +|---|---|---| +| 4인자·6필드·canonical bytes | 정상 입력의 정확한 bytes 및 기존 validator 일치; 타입·ID·경로 오류는 저장 전 거절 | 함수 단위 | +| 저장·read-back | 저장 경로 한정, bytes 일치; 오류·응답 불일치·close 실패는 실패 | offline IO | +| task 구조·빌드 | prepare가 첫 task, 지정 DAG, 두 code/mirror/hash 일치, 반복 빌드 동일 | 정적·offline | +| ingress 회귀 | 기존 strict request·두 read-pass 및 정상 11+E/diagnostic 5파일 계약 유지 | offline 회귀 | +| 실제 인자 공급·실패 차단·동시 실행 | 같은 인자의 전체 bytes 대조, prepare 실패 시 ingress 미호출, workspace 실행 경합 없음 | **backend 통합 후에만** | + +테스트용 fixture 통과를 실사건 실행, downstream handoff 완성, 법률 검증으로 해석하지 않는다. DEV release guard를 시험 편의상 제거하지 않는다. + +## Approval Boundaries + +이 요청은 **v2 계획 문서 작성**이다. 구현·배포·원격 실행은 수행하지 않는다. 이후 구현 요청에서는 승인된 범위의 로컬 수정과 offline 시험을 진행하고, 실제 운영 호출·외부 쓰기가 필요한 단계의 권한을 그때 확인한다. + +## Progress + +- [x] v1의 Objective 이하 검토 및 backend 비의존 구현 순서로 개정 +- [x] 새 task의 첫 배치, 네 인자 함수, 저장/read-back·검증 계획 작성 +- [ ] 생성·저장 함수와 준비 task 구현 +- [ ] builder·binding·hash 갱신 및 offline 검증 +- [ ] backend 연동·동시 실행 검증 +- [ ] 구현 상태에 맞춘 분석·IO 문서 개정 + +## Decision Log + +| 결정 | 근거 | 결과 | +|---|---|---| +| 생성 코드와 운영 연결을 별도 완료 조건으로 둠 | 함수는 명시적 인자와 localdocs 대역으로 검증 가능 | backend 정보 미확인 상태에서도 구현 진행 | +| 두 task 구조와 첫 task 배치 유지 | 사용자가 지정한 Stage 2 작업명세서 순서 | 기존 단일 task 빌드 계약은 실제 구현 시 갱신 | +| 기존 validator·serializer·verified write 재사용 | 6필드·bytes·경로 계약이 이미 존재 | 중복 구현과 새 receipt 제거 | +| 후행 expected bytes 대조는 인자 결속 확인 후 적용 | 별개 task의 인자 동일성을 가정할 수 없음 | offline 호환성과 실제 동일 요청 소비를 구별 | + +## Evidence Ledger + +| 명제 | 확인된 자료 | 상태 | +|---|---|---| +| 기존 request는 6필드 고정 계약 | `R/runtime/s2_00_ingress.py`의 `_inline_validate_request`; `R/schemas/ingress.schema.json` | 기존 구현 확인 | +| 기존 직렬화·저장/read-back helper가 있음 | 같은 runtime의 `canonical_json_bytes`, `_InlineLocaldocs.write_binary_verified` | 기존 구현 확인 | +| 단일 task 빌더·고정 output 쓰기 root 변경 필요 | `R/offline_build/build_s2_00_inline_projection.py`, `R/deployment/stage2_code_executor_binding.yml` | 기존 제약 확인 | +| 실제 backend 인자 공급·성공 게이트·직렬화 | 현재 v1 및 관련 자료에서 확인되지 않음 | **UNVERIFIED; 생성 함수 구현을 막지 않음** | + +## Risks and Failure Modes + +- 두 task를 YAML에 나열하기만 해서는 외부 인자 공급이나 실패 시 후행 차단이 구현되지 않는다. backend 연결 확인 전에는 offline artifact로 표시한다. +- write/read-back은 그 순간의 bytes를 확인하지만 고정 경로의 동시 덮어쓰기를 막지 못한다. 실제 운영에는 workspace 단위 통제가 별도로 필요하다. +- 정본·배포본·mirror·receipt·binding의 hash를 따로 갱신하면 참조 불일치가 생긴다. 변경된 참조만 함께 재결속하고 반복 빌드로 확인한다. +- 현 release의 `DEV_FIXTURE_RELEASE / DRAFT_NOT_EXECUTABLE` 상태는 request 생성 기능의 구현만으로 바뀌지 않는다. + +## Results and Residual Uncertainty + +v2는 backend 기능 확인을 **생성 코드 구현의 선행 조건에서 운영 연결의 완료 조건으로 이동**시켰다. 실행 가능한 함수와 offline 저장 시험을 먼저 만들고, Stage 2 작업명세서에서 이를 첫 task로 배치하는 변경을 계획한다. 실제 인자 주입·후행 차단·동시 실행 통제의 구현 여부는 아직 확인되지 않았고, 이 계획 작성으로 request 파일이나 새 YAML이 생성된 것은 아니다.