From 3d546fb48a4bc672cdf4a241a9c747c6e67cb4a0 Mon Sep 17 00:00:00 2001 From: Brian Luby Date: Fri, 13 Nov 2026 21:49:51 -0800 Subject: [PATCH 1/2] feat(review): M-10 edit-capable /4 family with proposed-edit contract Add a separately closed edit-capable response family (/4) mirroring the /3 Authoring typed stack. Queues stay the closed /3 shape; only the response envelope gains proposed_edit: Option (target_subject_sha256, closed full-text patch_format, bounded 64 KiB patch, patch_sha256). - AC-5: a wrong target_subject_sha256 classifies that response stale; the merge continues and a clean response still fills its seat. - New closed invalid-edit ResponseClassification for malformed edit envelopes; per-response, never blocks other responses. - G-4 never-applied: proposed edits are inert unapproved patches; merge validates syntax + target hash only and never mutates native sources. - Zero-edit /1 /2 /3 families unchanged: ResponseIntake::ZeroEdit keeps the UnsupportedEdit refusal; /4 uses EditCapable. Existing contracts preserved. New CLI 'review edit' family (init/respond/merge/status) with an optional --proposed-patch file. 19 new M-10 regression tests; full suite green. Owner decision 2026-11-13: the four seal-less domain adapters (057 impact, 063 assessment, 064 POA&M, 066 AI) are DEFERRED to post-2.0.0 pending a domain-approval design decision; not built here. --- .../forge.review-dispositions-4.schema.json | 745 ++++++++++++++++++ schemas/forge.review-response-4.schema.json | 558 +++++++++++++ src/cli/mod.rs | 162 ++++ src/review/authoring_capture_tests.rs | 5 + src/review/authoring_commands_tests.rs | 1 + src/review/chain_v4.rs | 278 +++++++ src/review/commands.rs | 3 + src/review/commands_applicability_tests.rs | 2 + src/review/decode_v2.rs | 20 +- src/review/decode_v3.rs | 15 +- src/review/decode_v3_operational.rs | 4 +- src/review/decode_v4.rs | 15 + src/review/decode_v4_operational.rs | 212 +++++ src/review/decode_v4_tests.rs | 159 ++++ src/review/edit_binding.rs | 174 ++++ src/review/edit_codec_tests.rs | 293 +++++++ src/review/edit_commands.rs | 196 +++++ src/review/edit_finalize.rs | 448 +++++++++++ src/review/edit_merge_tests.rs | 349 ++++++++ src/review/edit_response.rs | 208 +++++ src/review/edit_response_binding.rs | 412 ++++++++++ src/review/encode_v3.rs | 13 +- src/review/encode_v4.rs | 17 + src/review/encode_v4_operational.rs | 299 +++++++ src/review/encode_v4_tests.rs | 132 ++++ src/review/html.rs | 1 + src/review/lifecycle_response_tests.rs | 2 +- src/review/merge.rs | 4 +- src/review/merge_v2.rs | 4 +- src/review/merge_v3.rs | 4 +- src/review/merge_v4.rs | 667 ++++++++++++++++ src/review/mod.rs | 23 + src/review/quorum_v4.rs | 272 +++++++ src/review/wire.rs | 2 + src/review/wire_v4.rs | 105 +++ src/review/wire_v4_tests.rs | 64 ++ 36 files changed, 5849 insertions(+), 19 deletions(-) create mode 100644 schemas/forge.review-dispositions-4.schema.json create mode 100644 schemas/forge.review-response-4.schema.json create mode 100644 src/review/chain_v4.rs create mode 100644 src/review/decode_v4.rs create mode 100644 src/review/decode_v4_operational.rs create mode 100644 src/review/decode_v4_tests.rs create mode 100644 src/review/edit_binding.rs create mode 100644 src/review/edit_codec_tests.rs create mode 100644 src/review/edit_commands.rs create mode 100644 src/review/edit_finalize.rs create mode 100644 src/review/edit_merge_tests.rs create mode 100644 src/review/edit_response.rs create mode 100644 src/review/edit_response_binding.rs create mode 100644 src/review/encode_v4.rs create mode 100644 src/review/encode_v4_operational.rs create mode 100644 src/review/encode_v4_tests.rs create mode 100644 src/review/merge_v4.rs create mode 100644 src/review/quorum_v4.rs create mode 100644 src/review/wire_v4.rs create mode 100644 src/review/wire_v4_tests.rs diff --git a/schemas/forge.review-dispositions-4.schema.json b/schemas/forge.review-dispositions-4.schema.json new file mode 100644 index 00000000..fa29350e --- /dev/null +++ b/schemas/forge.review-dispositions-4.schema.json @@ -0,0 +1,745 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "forge.review-dispositions/4", + "title": "forge.review-dispositions/4", + "description": "Proposed separately closed whole authoring-plan /3 exchange. Inert asserted declarations only; structural shape does not supply native preparation, alias/currentness/capture, authenticated identity or approval. Complete UTF-8 byte limits and all semantic correlations require the typed contract.", + "$ref": "#/$defs/DispositionsDocument", + "$defs": { + "key": { + "type": "string", + "minLength": 1, + "maxLength": 128, + "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]*$" + }, + "hash": { + "type": "string", + "pattern": "^[0-9a-f]{64}$" + }, + "uuid": { + "type": "string", + "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" + }, + "time": { + "type": "string", + "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$" + }, + "Disposition": { + "type": "string", + "enum": [ + "approve", + "reject", + "request-changes", + "abstain", + "superseded" + ] + }, + "ResponseClassification": { + "type": "string", + "enum": [ + "current", + "stale", + "foreign", + "future", + "late", + "unassigned", + "superseded", + "conflicted", + "invalid-edit" + ] + }, + "ItemState": { + "type": "string", + "enum": [ + "unassigned", + "assigned", + "in-review", + "conflicted", + "changes-requested", + "quorum-met", + "expired", + "stale", + "invalid-edit" + ] + }, + "RecordedCurrentness": { + "type": "string", + "enum": [ + "unverified", + "recorded-current" + ] + }, + "SourcePin": { + "type": "object", + "additionalProperties": false, + "required": [ + "artifact_key", + "kind", + "raw_sha256", + "byte_length", + "schema_identity", + "validation_profile", + "native_model", + "native_root_uuid" + ], + "properties": { + "artifact_key": { + "$ref": "#/$defs/key" + }, + "kind": { + "enum": [ + "author-project", + "authoring-pack", + "gap-report", + "applicability-manifest", + "framework", + "resolved-catalog", + "mapping-collection", + "human-clause", + "stored-plan" + ] + }, + "raw_sha256": { + "$ref": "#/$defs/hash" + }, + "byte_length": { + "type": "integer", + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "anyOf": [ + { + "enum": [ + "forge.author-project/1", + "forge.authoring-pack/1", + "forge.applicability-report/1", + "forge.applicability/1", + "forge.authoring-plan/1" + ] + }, + { + "type": "null" + } + ] + }, + "validation_profile": { + "enum": [ + "forge.author-project-intrinsic/1", + "forge.authoring-pack-intrinsic/1", + "forge.authoring-gap-report-complete/1", + "forge.authoring-applicability-intrinsic/1", + "forge.authoring-framework-native/1", + "forge.authoring-resolved-catalog-native/1", + "forge.authoring-mapping-native/1", + "forge.authoring-clause-validated/1", + "forge.authoring-plan-complete-equality/1" + ] + }, + "native_model": { + "anyOf": [ + { + "enum": [ + "catalog", + "profile", + "mapping-collection" + ] + }, + { + "type": "null" + } + ] + }, + "native_root_uuid": { + "anyOf": [ + { + "$ref": "#/$defs/native_uuid" + }, + { + "type": "null" + } + ] + } + }, + "oneOf": [ + { + "properties": { + "artifact_key": { + "const": "authoring:project" + }, + "kind": { + "const": "author-project" + }, + "byte_length": { + "minimum": 1, + "maximum": 2097152 + }, + "schema_identity": { + "const": "forge.author-project/1" + }, + "validation_profile": { + "const": "forge.author-project-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:pack" + }, + "kind": { + "const": "authoring-pack" + }, + "byte_length": { + "minimum": 1, + "maximum": 2097152 + }, + "schema_identity": { + "const": "forge.authoring-pack/1" + }, + "validation_profile": { + "const": "forge.authoring-pack-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:gap-report" + }, + "kind": { + "const": "gap-report" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.applicability-report/1" + }, + "validation_profile": { + "const": "forge.authoring-gap-report-complete/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:applicability" + }, + "kind": { + "const": "applicability-manifest" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.applicability/1" + }, + "validation_profile": { + "const": "forge.authoring-applicability-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:framework" + }, + "kind": { + "const": "framework" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-framework-native/1" + }, + "native_model": { + "enum": [ + "catalog", + "profile" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:resolved" + }, + "kind": { + "const": "resolved-catalog" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-resolved-catalog-native/1" + }, + "native_model": { + "enum": [ + "catalog" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "type": "string", + "pattern": "^authoring:mapping:(?:0|[1-9][0-9]?)$" + }, + "kind": { + "const": "mapping-collection" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-mapping-native/1" + }, + "native_model": { + "enum": [ + "mapping-collection" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "type": "string", + "pattern": "^authoring:clause:(?:0|[1-9][0-9]?)$" + }, + "kind": { + "const": "human-clause" + }, + "byte_length": { + "minimum": 1, + "maximum": 1048576 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-clause-validated/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:plan" + }, + "kind": { + "const": "stored-plan" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.authoring-plan/1" + }, + "validation_profile": { + "const": "forge.authoring-plan-complete-equality/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + } + ] + }, + "RecordedResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "response_id", + "raw_sha256", + "byte_length", + "item_key", + "reviewer_key", + "reviewer_role", + "disposition", + "responded_at", + "classification" + ], + "properties": { + "response_id": { + "$ref": "#/$defs/uuid" + }, + "raw_sha256": { + "$ref": "#/$defs/hash" + }, + "byte_length": { + "type": "integer", + "minimum": 1, + "maximum": 1048576 + }, + "item_key": { + "$ref": "#/$defs/key" + }, + "reviewer_key": { + "$ref": "#/$defs/key" + }, + "reviewer_role": { + "$ref": "#/$defs/key" + }, + "disposition": { + "$ref": "#/$defs/Disposition" + }, + "responded_at": { + "$ref": "#/$defs/time" + }, + "classification": { + "$ref": "#/$defs/ResponseClassification" + } + } + }, + "MetSeat": { + "type": "object", + "additionalProperties": false, + "required": [ + "role_key", + "ordinal", + "reviewer_key", + "response_id" + ], + "properties": { + "role_key": { + "$ref": "#/$defs/key" + }, + "ordinal": { + "type": "integer", + "minimum": 0, + "maximum": 99 + }, + "reviewer_key": { + "$ref": "#/$defs/key" + }, + "response_id": { + "$ref": "#/$defs/uuid" + } + } + }, + "UnmetSeat": { + "type": "object", + "additionalProperties": false, + "required": [ + "role_key", + "ordinal" + ], + "properties": { + "role_key": { + "$ref": "#/$defs/key" + }, + "ordinal": { + "type": "integer", + "minimum": 0, + "maximum": 99 + } + } + }, + "ItemDisposition": { + "type": "object", + "additionalProperties": false, + "required": [ + "item_key", + "item_id", + "state", + "reason_codes", + "required_seats", + "met_seats", + "unmet_seats", + "response_ids", + "dissent_ids", + "blocking" + ], + "properties": { + "item_key": { + "$ref": "#/$defs/key" + }, + "item_id": { + "$ref": "#/$defs/uuid" + }, + "state": { + "$ref": "#/$defs/ItemState" + }, + "reason_codes": { + "type": "array", + "items": { + "$ref": "#/$defs/key" + }, + "minItems": 0, + "maxItems": 32 + }, + "required_seats": { + "type": "integer", + "minimum": 1, + "maximum": 100 + }, + "met_seats": { + "type": "array", + "items": { + "$ref": "#/$defs/MetSeat" + }, + "minItems": 0, + "maxItems": 100 + }, + "unmet_seats": { + "type": "array", + "items": { + "$ref": "#/$defs/UnmetSeat" + }, + "minItems": 0, + "maxItems": 100 + }, + "response_ids": { + "type": "array", + "items": { + "$ref": "#/$defs/uuid" + }, + "minItems": 0, + "maxItems": 10000 + }, + "dissent_ids": { + "type": "array", + "items": { + "$ref": "#/$defs/uuid" + }, + "minItems": 0, + "maxItems": 10000 + }, + "blocking": { + "type": "boolean" + } + } + }, + "StateCounts": { + "type": "object", + "additionalProperties": false, + "required": [ + "unassigned", + "assigned", + "in_review", + "conflicted", + "changes_requested", + "quorum_met", + "expired", + "stale" + ], + "properties": { + "unassigned": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "assigned": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "in_review": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "conflicted": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "changes_requested": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "quorum_met": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "expired": { + "type": "integer", + "minimum": 0, + "maximum": 1 + }, + "stale": { + "type": "integer", + "minimum": 0, + "maximum": 1 + } + } + }, + "DispositionCounts": { + "type": "object", + "additionalProperties": false, + "required": [ + "items", + "response_files", + "unique_responses", + "exact_duplicates", + "states" + ], + "properties": { + "items": { + "const": 1 + }, + "response_files": { + "type": "integer", + "minimum": 0, + "maximum": 10000 + }, + "unique_responses": { + "type": "integer", + "minimum": 0, + "maximum": 10000 + }, + "exact_duplicates": { + "type": "integer", + "minimum": 0, + "maximum": 10000 + }, + "states": { + "$ref": "#/$defs/StateCounts" + } + } + }, + "DispositionsDocument": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "identity_disclaimer", + "queue_id", + "queue_raw_sha256", + "as_of", + "currentness", + "closure_generation", + "source_pins", + "responses", + "items", + "counts" + ], + "properties": { + "schema_version": { + "const": "forge.review-dispositions/4" + }, + "identity_disclaimer": { + "const": "keys-roles-authors-and-times-are-asserted-not-authenticated-signed-or-non-repudiable" + }, + "queue_id": { + "$ref": "#/$defs/uuid" + }, + "queue_raw_sha256": { + "$ref": "#/$defs/hash" + }, + "as_of": { + "$ref": "#/$defs/time" + }, + "currentness": { + "$ref": "#/$defs/RecordedCurrentness" + }, + "closure_generation": { + "anyOf": [ + { + "$ref": "#/$defs/hash" + }, + { + "type": "null" + } + ] + }, + "source_pins": { + "type": "array", + "items": { + "$ref": "#/$defs/SourcePin" + }, + "minItems": 6, + "maxItems": 100 + }, + "responses": { + "type": "array", + "items": { + "$ref": "#/$defs/RecordedResponse" + }, + "minItems": 0, + "maxItems": 10000 + }, + "items": { + "type": "array", + "items": { + "$ref": "#/$defs/ItemDisposition" + }, + "minItems": 1, + "maxItems": 1 + }, + "counts": { + "$ref": "#/$defs/DispositionCounts" + } + } + }, + "native_uuid": { + "type": "string", + "minLength": 32, + "maxLength": 45, + "pattern": "^(?:[0-9A-Fa-f]{32}|[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}|\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\}|urn:uuid:[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12})$" + } + } +} diff --git a/schemas/forge.review-response-4.schema.json b/schemas/forge.review-response-4.schema.json new file mode 100644 index 00000000..8b8bb8ea --- /dev/null +++ b/schemas/forge.review-response-4.schema.json @@ -0,0 +1,558 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "forge.review-response/4", + "title": "forge.review-response/4", + "description": "Proposed separately closed whole authoring-plan /4 edit-capable exchange. Inert asserted declarations only; structural shape does not supply native preparation, alias/currentness/capture, authenticated identity or approval. Complete UTF-8 byte limits and all semantic correlations require the typed contract.", + "$ref": "#/$defs/ResponseDocument", + "$defs": { + "key": { + "type": "string", + "minLength": 1, + "maxLength": 128, + "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]*$" + }, + "hash": { + "type": "string", + "pattern": "^[0-9a-f]{64}$" + }, + "uuid": { + "type": "string", + "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" + }, + "time": { + "type": "string", + "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$" + }, + "Domain": { + "const": "authoring-plan" + }, + "RequestedAction": { + "type": "string", + "enum": [ + "re-review" + ] + }, + "Disposition": { + "type": "string", + "enum": [ + "approve", + "reject", + "request-changes", + "abstain", + "superseded" + ] + }, + "SourcePin": { + "type": "object", + "additionalProperties": false, + "required": [ + "artifact_key", + "kind", + "raw_sha256", + "byte_length", + "schema_identity", + "validation_profile", + "native_model", + "native_root_uuid" + ], + "properties": { + "artifact_key": { + "$ref": "#/$defs/key" + }, + "kind": { + "enum": [ + "author-project", + "authoring-pack", + "gap-report", + "applicability-manifest", + "framework", + "resolved-catalog", + "mapping-collection", + "human-clause", + "stored-plan" + ] + }, + "raw_sha256": { + "$ref": "#/$defs/hash" + }, + "byte_length": { + "type": "integer", + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "anyOf": [ + { + "enum": [ + "forge.author-project/1", + "forge.authoring-pack/1", + "forge.applicability-report/1", + "forge.applicability/1", + "forge.authoring-plan/1" + ] + }, + { + "type": "null" + } + ] + }, + "validation_profile": { + "enum": [ + "forge.author-project-intrinsic/1", + "forge.authoring-pack-intrinsic/1", + "forge.authoring-gap-report-complete/1", + "forge.authoring-applicability-intrinsic/1", + "forge.authoring-framework-native/1", + "forge.authoring-resolved-catalog-native/1", + "forge.authoring-mapping-native/1", + "forge.authoring-clause-validated/1", + "forge.authoring-plan-complete-equality/1" + ] + }, + "native_model": { + "anyOf": [ + { + "enum": [ + "catalog", + "profile", + "mapping-collection" + ] + }, + { + "type": "null" + } + ] + }, + "native_root_uuid": { + "anyOf": [ + { + "$ref": "#/$defs/native_uuid" + }, + { + "type": "null" + } + ] + } + }, + "oneOf": [ + { + "properties": { + "artifact_key": { + "const": "authoring:project" + }, + "kind": { + "const": "author-project" + }, + "byte_length": { + "minimum": 1, + "maximum": 2097152 + }, + "schema_identity": { + "const": "forge.author-project/1" + }, + "validation_profile": { + "const": "forge.author-project-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:pack" + }, + "kind": { + "const": "authoring-pack" + }, + "byte_length": { + "minimum": 1, + "maximum": 2097152 + }, + "schema_identity": { + "const": "forge.authoring-pack/1" + }, + "validation_profile": { + "const": "forge.authoring-pack-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:gap-report" + }, + "kind": { + "const": "gap-report" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.applicability-report/1" + }, + "validation_profile": { + "const": "forge.authoring-gap-report-complete/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:applicability" + }, + "kind": { + "const": "applicability-manifest" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.applicability/1" + }, + "validation_profile": { + "const": "forge.authoring-applicability-intrinsic/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:framework" + }, + "kind": { + "const": "framework" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-framework-native/1" + }, + "native_model": { + "enum": [ + "catalog", + "profile" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:resolved" + }, + "kind": { + "const": "resolved-catalog" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-resolved-catalog-native/1" + }, + "native_model": { + "enum": [ + "catalog" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "type": "string", + "pattern": "^authoring:mapping:(?:0|[1-9][0-9]?)$" + }, + "kind": { + "const": "mapping-collection" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-mapping-native/1" + }, + "native_model": { + "enum": [ + "mapping-collection" + ] + }, + "native_root_uuid": { + "$ref": "#/$defs/native_uuid" + } + } + }, + { + "properties": { + "artifact_key": { + "type": "string", + "pattern": "^authoring:clause:(?:0|[1-9][0-9]?)$" + }, + "kind": { + "const": "human-clause" + }, + "byte_length": { + "minimum": 1, + "maximum": 1048576 + }, + "schema_identity": { + "type": "null" + }, + "validation_profile": { + "const": "forge.authoring-clause-validated/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + }, + { + "properties": { + "artifact_key": { + "const": "authoring:plan" + }, + "kind": { + "const": "stored-plan" + }, + "byte_length": { + "minimum": 1, + "maximum": 10485760 + }, + "schema_identity": { + "const": "forge.authoring-plan/1" + }, + "validation_profile": { + "const": "forge.authoring-plan-complete-equality/1" + }, + "native_model": { + "type": "null" + }, + "native_root_uuid": { + "type": "null" + } + } + } + ] + }, + "SupersessionReference": { + "type": "object", + "additionalProperties": false, + "required": [ + "response_id", + "raw_sha256" + ], + "properties": { + "response_id": { + "$ref": "#/$defs/uuid" + }, + "raw_sha256": { + "$ref": "#/$defs/hash" + } + } + }, + "ResponseDocument": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "identity_disclaimer", + "response_id", + "queue_id", + "queue_raw_sha256", + "item_key", + "item_id", + "domain", + "adapter_version", + "requested_action", + "source_pins", + "subject_sha256", + "context_sha256", + "policy_sha256", + "reviewer_key", + "reviewer_role", + "disposition", + "responded_at", + "rationale", + "abstention_reason", + "proposed_edit", + "supersedes" + ], + "properties": { + "schema_version": { + "const": "forge.review-response/4" + }, + "identity_disclaimer": { + "const": "keys-roles-authors-and-times-are-asserted-not-authenticated-signed-or-non-repudiable" + }, + "response_id": { + "$ref": "#/$defs/uuid" + }, + "queue_id": { + "$ref": "#/$defs/uuid" + }, + "queue_raw_sha256": { + "$ref": "#/$defs/hash" + }, + "item_key": { + "$ref": "#/$defs/key" + }, + "item_id": { + "$ref": "#/$defs/uuid" + }, + "domain": { + "$ref": "#/$defs/Domain" + }, + "adapter_version": { + "const": "forge.authoring-plan-review/1" + }, + "requested_action": { + "$ref": "#/$defs/RequestedAction" + }, + "source_pins": { + "type": "array", + "items": { + "$ref": "#/$defs/SourcePin" + }, + "minItems": 6, + "maxItems": 100 + }, + "subject_sha256": { + "$ref": "#/$defs/hash" + }, + "context_sha256": { + "$ref": "#/$defs/hash" + }, + "policy_sha256": { + "$ref": "#/$defs/hash" + }, + "reviewer_key": { + "$ref": "#/$defs/key" + }, + "reviewer_role": { + "$ref": "#/$defs/key" + }, + "disposition": { + "$ref": "#/$defs/Disposition" + }, + "responded_at": { + "$ref": "#/$defs/time" + }, + "rationale": { + "type": "string", + "maxLength": 8192 + }, + "abstention_reason": { + "anyOf": [ + { + "$ref": "#/$defs/key" + }, + { + "type": "null" + } + ] + }, + "proposed_edit": { + "$ref": "#/$defs/ProposedEdit" + }, + "supersedes": { + "anyOf": [ + { + "$ref": "#/$defs/SupersessionReference" + }, + { + "type": "null" + } + ] + } + } + }, + "native_uuid": { + "type": "string", + "minLength": 32, + "maxLength": 45, + "pattern": "^(?:[0-9A-Fa-f]{32}|[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}|\\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\}|urn:uuid:[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12})$" + }, + "ProposedEdit": { + "oneOf": [ + { + "type": "null" + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "target_subject_sha256", + "patch_format", + "patch", + "patch_sha256" + ], + "properties": { + "target_subject_sha256": { + "$ref": "#/$defs/hash" + }, + "patch_format": { + "type": "string", + "enum": [ + "full-text" + ] + }, + "patch": { + "type": "string", + "minLength": 1, + "maxLength": 65536 + }, + "patch_sha256": { + "$ref": "#/$defs/hash" + } + } + } + ] + } + } +} diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 76d0f59e..065d6e4c 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -432,6 +432,13 @@ pub enum ReviewCommand { #[command(subcommand)] command: AuthoringReviewCommand, }, + /// Review one complete current Authoring plan with the edit-capable closed /4 exchange + #[command(after_help = REVIEW_IDENTITY_HELP)] + Edit { + /// Explicit native-derived init, respond (optionally with a proposed edit) or merge/status. + #[command(subcommand)] + command: EditReviewCommand, + }, /// Review one recorded Lifecycle policy/version with a separate closed /2 exchange #[command(after_help = REVIEW_IDENTITY_HELP)] Lifecycle { @@ -752,6 +759,7 @@ fn run_review(command: &ReviewCommand) -> Result<(), ForgeError> { let result = match command { ReviewCommand::Lifecycle { command } => return run_lifecycle_review(command), ReviewCommand::Authoring { command } => return run_authoring_review(command), + ReviewCommand::Edit { command } => return run_edit_review(command), ReviewCommand::Init(args) => commands::init( &commands::InitOptions { project_root: &args.project_root, @@ -793,6 +801,7 @@ fn run_review(command: &ReviewCommand) -> Result<(), ForgeError> { response_id: &args.response_id, abstention_reason: args.abstention_reason.as_deref(), supersedes, + proposed_patch: None, output: &args.output, }, &mut control, @@ -886,6 +895,7 @@ fn run_lifecycle_review(command: &LifecycleReviewCommand) -> Result<(), ForgeErr response_id: &args.response_id, abstention_reason: args.abstention_reason.as_deref(), supersedes, + proposed_patch: None, output: &args.output, }, &mut control, @@ -3288,6 +3298,157 @@ pub struct AuthoringReviewInitArgs { pub output: PathBuf, } +/// Edit-capable /4 family: init produces the unchanged /3 queue; respond may carry an +/// inert proposed edit; merge/status validate each edit per response and never apply it. +#[derive(Subcommand)] +#[deny(missing_docs)] +#[command(after_help = REVIEW_IDENTITY_HELP)] +pub enum EditReviewCommand { + /// Create one queue from a complete current native plan and private asserted review policy + #[command(after_help = REVIEW_IDENTITY_HELP)] + Init( + /// Complete private native locator, asserted policy, identities and new destination. + Box, + ), + /// Write an immutable private assertion, optionally with an inert proposed edit + #[command(after_help = REVIEW_IDENTITY_HELP)] + Respond( + /// Explicit reviewer, disposition, time, private rationale, optional patch and destination. + Box, + ), + /// Merge every response occurrence against the complete current native plan + #[command(after_help = REVIEW_IDENTITY_HELP)] + Merge( + /// Whole native, queue and response originals, evaluation time and new destination. + Box, + ), + /// Compute the current recorded bundle without publishing a new file + #[command(after_help = REVIEW_IDENTITY_HELP)] + Status( + /// Whole native, queue and response originals and explicit evaluation time. + Box, + ), +} + +/// Explicit immutable edit-capable response arguments; the proposed patch is inert data. +#[derive(clap::Args)] +#[deny(missing_docs)] +pub struct EditReviewRespondArgs { + /// Actual normalized root for the queue, rationale, patch and destination + #[arg(long)] + pub project_root: PathBuf, + /// Exact immutable queue original + #[arg(long)] + pub queue: PathBuf, + /// Selected queue-local item key + #[arg(long)] + pub item_key: String, + /// Asserted reviewer key, with no identity lookup or authentication + #[arg(long)] + pub reviewer_key: String, + /// Asserted reviewer role, checked against the explicit assignment + #[arg(long)] + pub reviewer_role: String, + /// Independent disposition to retain + #[arg(long, value_enum)] + pub disposition: ReviewDisposition, + /// Asserted response time in canonical UTC seconds + #[arg(long)] + pub responded_at: String, + /// Explicit canonical response UUID + #[arg(long)] + pub response_id: String, + /// Confined UTF-8 private rationale file, at most8 KiB + #[arg(long)] + pub rationale_file: PathBuf, + /// Explicit policy-defined reason permitting an empty abstention rationale + #[arg(long)] + pub abstention_reason: Option, + /// Explicit previous response UUID; requires its exact original hash + #[arg(long, requires = "supersedes_sha256")] + pub supersedes_id: Option, + /// Exact SHA-256 of the previous response original; requires its UUID + #[arg(long, requires = "supersedes_id")] + pub supersedes_sha256: Option, + /// Confined UTF-8 proposed replacement patch file, at most64 KiB; inert until promoted + #[arg(long)] + pub proposed_patch: Option, + /// Confined new response file; existing destinations are refused + #[arg(long)] + pub output: PathBuf, +} + +/// Dispatch the edit-capable /4 family through complete actual operation owners. +fn run_edit_review(command: &EditReviewCommand) -> Result<(), ForgeError> { + use crate::review::{commands, edit_commands}; + let mut control = crate::workspace::preparation::NoopControl; + let result = match command { + EditReviewCommand::Init(args) => edit_commands::init( + &commands::InitOptions { + project_root: &args.project_root, + sources: &args.sources, + policy: &args.policy, + queue_id: &args.queue_id, + created_at: &args.created_at, + output: &args.output, + }, + &mut control, + ), + EditReviewCommand::Respond(args) => { + let disposition = match args.disposition { + ReviewDisposition::Approve => crate::review::wire::Disposition::Approve, + ReviewDisposition::Reject => crate::review::wire::Disposition::Reject, + ReviewDisposition::RequestChanges => { + crate::review::wire::Disposition::RequestChanges + } + ReviewDisposition::Abstain => crate::review::wire::Disposition::Abstain, + ReviewDisposition::Superseded => crate::review::wire::Disposition::Superseded, + }; + let supersedes = match (&args.supersedes_id, &args.supersedes_sha256) { + (None, None) => None, + (Some(response_id), Some(raw_sha256)) => { + Some(commands::Supersedes { response_id, raw_sha256 }) + } + _ => return Err(ForgeError::Validation("invalid review response chain".into())), + }; + let patch = match &args.proposed_patch { + None => None, + Some(path) => Some( + std::fs::read(path) + .map_err(|_| ForgeError::Validation("cannot read proposed patch".into()))?, + ), + }; + edit_commands::respond( + &commands::RespondOptions { + project_root: &args.project_root, + queue: &args.queue, + rationale_file: &args.rationale_file, + item_key: &args.item_key, + reviewer_key: &args.reviewer_key, + reviewer_role: &args.reviewer_role, + disposition, + responded_at: &args.responded_at, + response_id: &args.response_id, + abstention_reason: args.abstention_reason.as_deref(), + supersedes, + proposed_patch: patch.as_deref(), + output: &args.output, + }, + &mut control, + ) + } + EditReviewCommand::Merge(args) => { + edit_commands::merge(&review_current_options(&args.current), &args.output, &mut control) + } + EditReviewCommand::Status(args) => edit_commands::status( + &review_current_options(args), + &mut std::io::stdout().lock(), + &mut control, + ), + }; + result.map_err(review_error) +} + /// Dispatch the separate Authoring /3 family through complete actual operation owners. fn run_authoring_review(command: &AuthoringReviewCommand) -> Result<(), ForgeError> { use crate::review::{authoring_commands, commands}; @@ -3334,6 +3495,7 @@ fn run_authoring_review(command: &AuthoringReviewCommand) -> Result<(), ForgeErr response_id: &args.response_id, abstention_reason: args.abstention_reason.as_deref(), supersedes, + proposed_patch: None, output: &args.output, }, &mut control, diff --git a/src/review/authoring_capture_tests.rs b/src/review/authoring_capture_tests.rs index c47ffad7..c3681f8d 100644 --- a/src/review/authoring_capture_tests.rs +++ b/src/review/authoring_capture_tests.rs @@ -587,3 +587,8 @@ mod init_export_tests { mod command_tests { include!("authoring_commands_tests.rs"); } + +/// Genuine edit-capable /4 merge controls: AC-5, invalid-edit, never-applied, round-trip. +mod edit_merge_tests { + include!("edit_merge_tests.rs"); +} diff --git a/src/review/authoring_commands_tests.rs b/src/review/authoring_commands_tests.rs index 15798c01..39d5a862 100644 --- a/src/review/authoring_commands_tests.rs +++ b/src/review/authoring_commands_tests.rs @@ -87,6 +87,7 @@ fn respond( None }, supersedes: None, + proposed_patch: None, output: Path::new(output), }, caller, diff --git a/src/review/chain_v4.rs b/src/review/chain_v4.rs new file mode 100644 index 00000000..cebfb5ec --- /dev/null +++ b/src/review/chain_v4.rs @@ -0,0 +1,278 @@ +// A-authored separately typed /4 successor; old /1 and /2 source bodies are untouched. +//! Separate /4 typed-family successor; no /1 document or source-pin cast. +//! Exact response-original registry and complete self-supersession graph. +//! Every distinct original is retained by the caller; this module borrows it. +//! Chain facts are assertions, not authenticated withdrawals or native proof. + +use super::chain_v3::visit; +use super::decode::{ContractError, ContractLedger, OriginalRelation}; +use super::decode_v3::DecodedV3; +use super::edit_response_binding::original_relation; +use super::wire_v4::ResponseDocumentV4; +use crate::workspace::preparation::WorkControl; +use std::cmp::Ordering; + +/// Complete borrowed originals plus deterministic unique identity/chain indices. +pub(crate) struct ResponseRegistryV4<'a> { + /// Every actual original, including exact duplicate files. + originals: &'a [DecodedV3<'a, ResponseDocumentV4>], + /// One representative per exact UUID/raw identity, ordered by UUID. + unique: Vec, + /// Exact prior index in the unique registry, or no withdrawal link. + targets: Vec>, + /// Additional files with exactly identical UUID and complete bytes. + duplicates: usize, +} + +impl<'a> ResponseRegistryV4<'a> { + /// Preserve every raw holder; a unique representative never releases one. + pub(crate) fn originals(&self) -> &'a [DecodedV3<'a, ResponseDocumentV4>] { + self.originals + } + /// Number of distinct actual response identities, not file count. + pub(crate) fn len(&self) -> usize { + self.unique.len() + } + /// Complete additional exact-file count. + pub(crate) fn duplicates(&self) -> usize { + self.duplicates + } + /// Borrow one actual admitted original through its deterministic index. + pub(crate) fn get(&self, index: usize) -> &'a DecodedV3<'a, ResponseDocumentV4> { + &self.originals[self.unique[index]] + } + /// Borrow the validated direct prior edge; no timestamp chooses a branch. + pub(crate) fn target(&self, index: usize) -> Option { + self.targets[index] + } +} + +use super::chain::{compare, reserved}; + +/// Iterative stable merge sort of borrowed indices with all comparisons charged. +fn ordered( + originals: &[DecodedV3<'_, ResponseDocumentV4>], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut indices = reserved(originals.len(), ledger)?; + let mut scratch = reserved(originals.len(), ledger)?; + for index in 0..originals.len() { + visit(ledger, control)?; + indices.push(index); + scratch.push(index); + } + let mut width = 1_usize; + while width < indices.len() { + let mut start = 0_usize; + while start < indices.len() { + visit(ledger, control)?; + let middle = start.saturating_add(width).min(indices.len()); + let end = middle.saturating_add(width).min(indices.len()); + merge_window(originals, &indices, &mut scratch, (start, middle, end), ledger, control)?; + start = end; + } + std::mem::swap(&mut indices, &mut scratch); + width = width.checked_mul(2).ok_or(ContractError::Capacity)?; + } + Ok(indices) +} + +/// Merge one bounded window without cloning documents or omitting repeats. +fn merge_window( + originals: &[DecodedV3<'_, ResponseDocumentV4>], + indices: &[usize], + scratch: &mut [usize], + window: (usize, usize, usize), + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let (start, middle, end) = window; + let mut left = start; + let mut right = middle; + for slot in &mut scratch[start..end] { + visit(ledger, control)?; + let choose_left = right == end + || (left < middle + && compare( + &originals[indices[left]].document().response_id, + &originals[indices[right]].document().response_id, + ledger, + )? != Ordering::Greater); + ledger.bytes(std::mem::size_of::())?; + *slot = if choose_left { + let value = indices[left]; + left += 1; + value + } else { + let value = indices[right]; + right += 1; + value + }; + } + Ok(()) +} + +/// Locate an exact UUID without case folding or unbounded registry scans. +fn locate( + registry: &ResponseRegistryV4<'_>, + id: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut low = 0; + let mut high = registry.len(); + while low < high { + visit(ledger, control)?; + let middle = low + (high - low) / 2; + match compare(®istry.get(middle).document().response_id, id, ledger)? { + Ordering::Less => low = middle + 1, + Ordering::Greater => high = middle, + Ordering::Equal => return Ok(Some(middle)), + } + } + Ok(None) +} + +/// A withdrawal binds the complete same queue/item/reviewer snapshot. +/// Two complete raw extents conservatively cover all repeated typed fields. +fn same_subject( + left: &DecodedV3<'_, ResponseDocumentV4>, + right: &DecodedV3<'_, ResponseDocumentV4>, + ledger: &mut ContractLedger, +) -> Result { + ledger + .bytes(left.raw().len().checked_add(right.raw().len()).ok_or(ContractError::Capacity)?)?; + let left = left.document(); + let right = right.document(); + Ok(left.queue_id == right.queue_id + && left.queue_raw_sha256 == right.queue_raw_sha256 + && left.item_key == right.item_key + && left.item_id == right.item_id + && left.domain == right.domain + && left.adapter_version == right.adapter_version + && left.requested_action == right.requested_action + && left.source_pins == right.source_pins + && left.subject_sha256 == right.subject_sha256 + && left.context_sha256 == right.context_sha256 + && left.policy_sha256 == right.policy_sha256 + && left.reviewer_key == right.reviewer_key + && left.reviewer_role == right.reviewer_role) +} + +/// Validate every edge, including future/late/history facts, before retirement. +fn edges( + registry: &mut ResponseRegistryV4<'_>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let mut successors = reserved(registry.len(), ledger)?; + for _ in 0..registry.len() { + visit(ledger, control)?; + successors.push(false); + registry.targets.push(None); + } + for index in 0..registry.len() { + visit(ledger, control)?; + if let Some(prior) = ®istry.get(index).document().supersedes { + let target = locate(registry, &prior.response_id, ledger, control)? + .ok_or(ContractError::InvalidChain)?; + ledger.bytes( + prior + .raw_sha256 + .len() + .checked_add(registry.get(target).raw_sha256().len()) + .ok_or(ContractError::Capacity)?, + )?; + if target == index + || successors[target] + || prior.raw_sha256 != registry.get(target).raw_sha256() + || !same_subject(registry.get(index), registry.get(target), ledger)? + { + return Err(ContractError::InvalidChain); + } + successors[target] = true; + registry.targets[index] = Some(target); + } + } + acyclic(®istry.targets, ledger, control) +} + +/// Detect cycles iteratively; no recursive stack or convenient partial chain. +fn acyclic( + targets: &[Option], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let mut colors = reserved(targets.len(), ledger)?; + let mut path = reserved(targets.len(), ledger)?; + for _ in 0..targets.len() { + visit(ledger, control)?; + colors.push(0_u8); + } + for start in 0..targets.len() { + visit(ledger, control)?; + if colors[start] != 0 { + continue; + } + path.clear(); + let mut cursor = Some(start); + while let Some(index) = cursor { + visit(ledger, control)?; + if index >= targets.len() { + return Err(ContractError::InvalidChain); + } + if colors[index] == 1 { + return Err(ContractError::InvalidChain); + } + if colors[index] == 2 { + break; + } + colors[index] = 1; + path.push(index); + cursor = targets[index]; + } + for &index in &path { + visit(ledger, control)?; + colors[index] = 2; + } + } + Ok(()) +} + +/// Reject any ambiguous original/chain as a whole, without consuming holders. +pub(crate) fn prepare<'a>( + originals: &'a [DecodedV3<'a, ResponseDocumentV4>], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + super::decode_v2::phase(ledger, control, |ledger, control| { + if originals.len() > 10_000 { + return Err(ContractError::Capacity); + } + let sorted = ordered(originals, ledger, control)?; + let mut unique = reserved(sorted.len(), ledger)?; + let mut duplicates = 0_usize; + for index in sorted { + visit(ledger, control)?; + let relation = match unique.last() { + Some(&prior) => { + original_relation(&originals[prior], &originals[index], ledger, control)? + } + None => OriginalRelation::DifferentIdentity, + }; + match relation { + OriginalRelation::DifferentIdentity => unique.push(index), + OriginalRelation::ExactDuplicate => { + duplicates = duplicates.checked_add(1).ok_or(ContractError::Capacity)?; + } + OriginalRelation::IdentityConflict => return Err(ContractError::IdentityConflict), + } + } + let targets = reserved(unique.len(), ledger)?; + let mut registry = ResponseRegistryV4 { originals, unique, targets, duplicates }; + edges(&mut registry, ledger, control)?; + ledger.checkpoint(control)?; + Ok(registry) + }) +} diff --git a/src/review/commands.rs b/src/review/commands.rs index 5e5d113b..51d7b5d3 100644 --- a/src/review/commands.rs +++ b/src/review/commands.rs @@ -90,6 +90,9 @@ pub(crate) struct RespondOptions<'a> { pub(crate) abstention_reason: Option<&'a str>, /// Complete explicit prior ID/hash pair or explicit absence. pub(crate) supersedes: Option>, + /// Optional bounded proposed replacement patch bytes; only the edit-capable /4 + /// family consumes this. The zero-edit /1 /2 /3 families always ignore it. + pub(crate) proposed_patch: Option<&'a [u8]>, /// Confined new response file; actual native no-replace publication only. pub(crate) output: &'a Path, } diff --git a/src/review/commands_applicability_tests.rs b/src/review/commands_applicability_tests.rs index f11d5487..a35a0a74 100644 --- a/src/review/commands_applicability_tests.rs +++ b/src/review/commands_applicability_tests.rs @@ -114,6 +114,7 @@ fn response(fixture: &Fixture, ordinal: usize, disposition: Disposition) -> Path response_id: RESPONSE_IDS[ordinal], abstention_reason: None, supersedes: None, + proposed_patch: None, output: &output, }, &mut NoopControl, @@ -562,6 +563,7 @@ fn actual_queue_response_and_merge_outputs_preserve_existing_bytes() { response_id: RESPONSE_IDS[0], abstention_reason: None, supersedes: None, + proposed_patch: None, output: &first, }, &mut NoopControl diff --git a/src/review/decode_v2.rs b/src/review/decode_v2.rs index b2fff7f7..f40406e9 100644 --- a/src/review/decode_v2.rs +++ b/src/review/decode_v2.rs @@ -1579,13 +1579,25 @@ pub(crate) mod structural { pub(crate) mod operational_raw { use super::{ContractError, ContractLedger, DeserializeOwned, WorkControl, phase}; + /// Closed response-intake policy: the zero-edit families refuse a non-null proposed + /// edit, while the edit-capable /4 family admits it as inert per-response evidence. + #[derive(Clone, Copy)] + pub(crate) enum ResponseIntake { + /// Zero-edit response family (/1 /2 /3): a non-null proposed edit is refused. + ZeroEdit, + /// Edit-capable response family (/4): the proposed edit is admitted as inert data. + EditCapable, + /// Recorded dispositions bundle: no response accounting or edit slot. + Recorded, + } + /// Preserve cap/empty/BOM preflight, response accounting and edit-before-schema order. /// Return only owned inert data and an actual original-byte digest, without a /2 cast. pub(crate) fn admitted_document( raw: &[u8], cap: usize, schema_text: &str, - response: bool, + intake: ResponseIntake, ledger: &mut ContractLedger, control: &mut dyn WorkControl, ) -> Result<(T, String), ContractError> { @@ -1600,13 +1612,15 @@ pub(crate) mod operational_raw { if raw.is_empty() || raw.starts_with(&[0xef, 0xbb, 0xbf]) { return Err(ContractError::Invalid); } - if response { + if matches!(intake, ResponseIntake::ZeroEdit | ResponseIntake::EditCapable) { ledger.response_registration(raw.len())?; } let value = super::value(raw, ledger, control)?; ledger.bytes(raw.len())?; ledger.visits(1)?; - if response && value.get("proposed_edit").is_some_and(|edit| !edit.is_null()) { + if matches!(intake, ResponseIntake::ZeroEdit) + && value.get("proposed_edit").is_some_and(|edit| !edit.is_null()) + { return Err(ContractError::UnsupportedEdit); } super::schema(&value, raw.len(), schema_text, ledger, control)?; diff --git a/src/review/decode_v3.rs b/src/review/decode_v3.rs index 8753e70d..5fc2b728 100644 --- a/src/review/decode_v3.rs +++ b/src/review/decode_v3.rs @@ -27,9 +27,14 @@ impl<'a, T> DecodedV3<'a, T> { pub(crate) fn raw_sha256(&self) -> &str { &self.raw_sha256 } + /// Wrap already-admitted declarations with their exact original bytes and digest. + /// Only the separately closed sibling codecs call this; it confers no native proof. + pub(crate) fn from_admitted(raw: &'a [u8], raw_sha256: String, document: T) -> Self { + Self { raw, raw_sha256, document } + } } /// Admit complete compared strings before any repeated exact scan/equality. -fn compared(values: &[&str], ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn compared(values: &[&str], ledger: &mut ContractLedger) -> Result<(), ContractError> { ledger.visits(values.len())?; for value in values { ledger.bytes(value.len())?; @@ -37,12 +42,12 @@ fn compared(values: &[&str], ledger: &mut ContractLedger) -> Result<(), Contract Ok(()) } /// Exact ASCII token grammar under the declared UTF-8 byte bound. -fn key(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn key(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { compared(&[value], ledger)?; super::validate::token(value, 128) } /// Exact lowercase full digest syntax without coercion or native truth. -fn hash(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn hash(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { compared(&[value], ledger)?; if value.len() != 64 || !value.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) { @@ -51,14 +56,14 @@ fn hash(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { Ok(()) } /// Preserve canonical nonnil review UUID text and its original spelling. -fn uuid(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn uuid(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { let bytes = value.len().checked_mul(3).ok_or_else(|| ledger.capacity())?; ledger.bytes(bytes)?; ledger.derived(128)?; super::validate::uuid(value) } /// Exact real UTC calendar seconds; no offset or wall-clock normalization. -fn time(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn time(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { let bytes = value.len().checked_mul(3).ok_or_else(|| ledger.capacity())?; ledger.bytes(bytes)?; ledger.derived(128)?; diff --git a/src/review/decode_v3_operational.rs b/src/review/decode_v3_operational.rs index 9207b115..7d63a5d2 100644 --- a/src/review/decode_v3_operational.rs +++ b/src/review/decode_v3_operational.rs @@ -178,7 +178,7 @@ pub(crate) fn decode_response<'a>( raw, MAX_RESPONSE_BYTES, include_str!("../../schemas/forge.review-response-3.schema.json"), - true, + operational_raw::ResponseIntake::ZeroEdit, ledger, control, )?; @@ -197,7 +197,7 @@ pub(crate) fn decode_dispositions<'a>( raw, MAX_RECORDED_BYTES, include_str!("../../schemas/forge.review-dispositions-3.schema.json"), - false, + operational_raw::ResponseIntake::Recorded, ledger, control, )?; diff --git a/src/review/decode_v4.rs b/src/review/decode_v4.rs new file mode 100644 index 00000000..296df68c --- /dev/null +++ b/src/review/decode_v4.rs @@ -0,0 +1,15 @@ +//! Strict separately closed edit-capable Response/4 and Dispositions/4 intake. +//! Queues remain the closed /3 shape; only the response envelope gains an optional +//! inert proposed edit. Decoding supplies no native facts or currentness owner. + +pub(crate) use super::decode::{ContractError, ContractLedger}; +pub(crate) use super::decode_v3::{DecodedV3, compared, hash, key, time, uuid}; + +/// Separately closed plain Response/4 and recorded Dispositions/4 intake. +#[path = "decode_v4_operational.rs"] +mod operational; +pub(crate) use operational::{decode_dispositions, decode_response, dispositions, response}; + +#[cfg(test)] +#[path = "decode_v4_tests.rs"] +mod tests; diff --git a/src/review/decode_v4_operational.rs b/src/review/decode_v4_operational.rs new file mode 100644 index 00000000..48a1c48e --- /dev/null +++ b/src/review/decode_v4_operational.rs @@ -0,0 +1,212 @@ +//! Plain Response/4 and recorded Dispositions/4 intake, with no native or policy owner. +use super::{ContractError, ContractLedger, DecodedV3, compared, hash, key, time, uuid}; +use crate::review::decode_v2::{operational_raw, phase, recorded_data}; +use crate::review::wire_v4::{ + ADAPTER, Disposition, DispositionsDocumentV4, IDENTITY_DISCLAIMER, ItemState, RESPONSE_VERSION, + RecordedCurrentness, ResponseDocumentV4, +}; +use crate::workspace::preparation::WorkControl; + +/// Full response raw ceiling, including emitted LF on finite output. +pub(crate) const MAX_RESPONSE_BYTES: usize = 1_048_576; +/// Full recorded raw ceiling intersected with unchanged monotonic derived/work bounds. +pub(crate) const MAX_RECORDED_BYTES: usize = 33_554_432; + +/// Validate all asserted immutable response data; actual Queue binding remains separate. +pub(crate) fn response( + document: &ResponseDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + crate::review::encode_v4::response_operands(document, ledger, control)?; + compared( + &[&document.schema_version, &document.identity_disclaimer, &document.adapter_version], + ledger, + )?; + if document.schema_version != RESPONSE_VERSION + || document.identity_disclaimer != IDENTITY_DISCLAIMER + || document.adapter_version != ADAPTER + { + return Err(ContractError::Invalid); + } + for value in [&document.response_id, &document.queue_id, &document.item_id] { + uuid(value, ledger)?; + } + time(&document.responded_at, ledger)?; + crate::review::hash_v3::validate_public_pins(&document.source_pins, ledger, control)?; + for value in [&document.item_key, &document.reviewer_key, &document.reviewer_role] { + key(value, ledger)?; + } + for value in [ + &document.queue_raw_sha256, + &document.subject_sha256, + &document.context_sha256, + &document.policy_sha256, + ] { + compared(&[value], ledger)?; + hash(value, ledger)?; + } + if document.rationale.len() > 8192 { + return Err(ledger.capacity()); + } + compared(&[&document.rationale], ledger)?; + match (document.disposition, &document.abstention_reason) { + (Disposition::Abstain, Some(reason)) => key(reason, ledger)?, + (Disposition::Abstain, None) | (_, Some(_)) => return Err(ContractError::Invalid), + (_, None) if document.rationale.trim().is_empty() => { + return Err(ContractError::Invalid); + } + (_, None) => {} + } + match (document.disposition, &document.supersedes) { + (Disposition::Superseded, Some(prior)) => { + uuid(&prior.response_id, ledger)?; + compared(&[&prior.raw_sha256, &prior.response_id, &document.response_id], ledger)?; + hash(&prior.raw_sha256, ledger)?; + if prior.response_id == document.response_id { + return Err(ContractError::Invalid); + } + } + (Disposition::Superseded, None) | (_, Some(_)) => return Err(ContractError::Invalid), + (_, None) => {} + } + Ok(()) + }) +} +/// Complete recorded counters are data, never an evaluation or currentness certificate. +fn counters( + document: &DispositionsDocumentV4, + ledger: &mut ContractLedger, +) -> Result<(), ContractError> { + ledger.visits(12)?; + ledger.bytes(12 * 64)?; + let counts = &document.counts; + if counts.items != 1 + || document.items.len() != 1 + || usize::try_from(counts.unique_responses).map_err(|_| ledger.capacity())? + != document.responses.len() + || counts.response_files > 10_000 + || counts.response_files + != counts + .unique_responses + .checked_add(counts.exact_duplicates) + .ok_or_else(|| ledger.capacity())? + { + return Err(ContractError::Invalid); + } + let states = &counts.states; + let reported = [ + states.unassigned, + states.assigned, + states.in_review, + states.conflicted, + states.changes_requested, + states.quorum_met, + states.expired, + states.stale, + ]; + let selected = match document.items[0].state { + ItemState::Unassigned => 0, + ItemState::Assigned => 1, + ItemState::InReview => 2, + ItemState::Conflicted => 3, + ItemState::ChangesRequested => 4, + ItemState::QuorumMet => 5, + ItemState::Expired => 6, + ItemState::Stale => 7, + }; + let mut actual = [0_u32; 8]; + actual[selected] = 1; + if reported != actual { + return Err(ContractError::Invalid); + } + Ok(()) +} +/// Validate the whole inert recorded roster, witnesses, dissent, counters and nullable claim. +pub(crate) fn dispositions( + document: &DispositionsDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + crate::review::encode_v4::dispositions_operands(document, ledger, control)?; + compared(&[&document.schema_version, &document.identity_disclaimer], ledger)?; + if document.schema_version != "forge.review-dispositions/4" + || document.identity_disclaimer != IDENTITY_DISCLAIMER + { + return Err(ContractError::Invalid); + } + uuid(&document.queue_id, ledger)?; + compared(&[&document.queue_raw_sha256], ledger)?; + hash(&document.queue_raw_sha256, ledger)?; + time(&document.as_of, ledger)?; + match (document.currentness, &document.closure_generation) { + (RecordedCurrentness::Unverified, None) => {} + (RecordedCurrentness::RecordedCurrent, Some(value)) => { + compared(&[value], ledger)?; + hash(value, ledger)?; + } + _ => return Err(ContractError::Invalid), + } + crate::review::hash_v3::validate_public_pins(&document.source_pins, ledger, control)?; + recorded_data::rows(&document.responses, ledger, control)?; + if document.items.len() != 1 { + return Err(ContractError::Invalid); + } + let item = &document.items[0]; + if item.reason_codes.len() > 32 + || item.response_ids.len() > 10_000 + || item.dissent_ids.len() > 10_000 + || item.met_seats.len() > 100 + || item.unmet_seats.len() > 100 + { + return Err(ContractError::Invalid); + } + recorded_data::item(item, &document.responses, ledger, control)?; + counters(document, ledger) + }) +} +/// Decode actual borrowed original Response/3 bytes, preserving preflight registration/edit order. +pub(crate) fn decode_response<'a>( + raw: &'a [u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + let (document, raw_sha256) = operational_raw::admitted_document( + raw, + MAX_RESPONSE_BYTES, + include_str!("../../schemas/forge.review-response-4.schema.json"), + operational_raw::ResponseIntake::EditCapable, + ledger, + control, + )?; + response(&document, ledger, control)?; + Ok(DecodedV3::from_admitted(raw, raw_sha256, document)) + }) +} +/// Decode complete recorded Dispositions/3 claims, without issuing currentness or approval. +pub(crate) fn decode_dispositions<'a>( + raw: &'a [u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + let (document, raw_sha256) = operational_raw::admitted_document( + raw, + MAX_RECORDED_BYTES, + include_str!("../../schemas/forge.review-dispositions-4.schema.json"), + operational_raw::ResponseIntake::Recorded, + ledger, + control, + )?; + dispositions(&document, ledger, control)?; + Ok(DecodedV3::from_admitted(raw, raw_sha256, document)) + }) +} + +#[cfg(test)] +#[path = "edit_codec_tests.rs"] +/// Genuine plain byte/record/counter/fence controls; no native success fixtures. +mod tests; diff --git a/src/review/decode_v4_tests.rs b/src/review/decode_v4_tests.rs new file mode 100644 index 00000000..732f319e --- /dev/null +++ b/src/review/decode_v4_tests.rs @@ -0,0 +1,159 @@ +//! Edit-capable /4 decode admission controls: the closed schema shape gates intake while +//! semantic edit validity remains a per-response merge classification. Never native proof. +use super::{decode_response, response}; +use crate::hashing::sha256_hex; +use crate::review::decode::{ContractError, ContractLedger}; +use crate::review::wire_v3::NativeModelV3; +use crate::review::wire_v4::{ + ADAPTER, Disposition, DomainV3, IDENTITY_DISCLAIMER, PatchFormat, ProposedEdit, + RequestedAction, ResponseDocumentV4, SourceKindV3, SourcePinV3, +}; +use crate::workspace::preparation::NoopControl; +use serde_json::Value; + +/// Canonical plain review identity. +fn id(n: u8) -> String { + format!("{n:08x}-1111-4111-8111-111111111111") +} +/// One ordinary source pin; a digest is asserted data only. +fn pin(kind: SourceKindV3, key: &str, schema: Option<&str>, profile: &str) -> SourcePinV3 { + SourcePinV3 { + artifact_key: key.into(), + kind, + raw_sha256: "a".repeat(64), + byte_length: 17, + schema_identity: schema.map(str::to_owned), + validation_profile: profile.into(), + native_model: matches!(kind, SourceKindV3::Framework).then_some(NativeModelV3::Catalog), + native_root_uuid: matches!(kind, SourceKindV3::Framework) + .then(|| "AAAAAAAA-BBBB-4CCC-8DDD-EEEEEEEEEEEE".to_owned()), + } +} +/// The full ordinary six-purpose roster, sorted by artifact key. +fn pins() -> Vec { + let mut values = vec![ + pin( + SourceKindV3::AuthorProject, + "authoring:project", + Some("forge.author-project/1"), + "forge.author-project-intrinsic/1", + ), + pin( + SourceKindV3::AuthoringPack, + "authoring:pack", + Some("forge.authoring-pack/1"), + "forge.authoring-pack-intrinsic/1", + ), + pin( + SourceKindV3::GapReport, + "authoring:gap-report", + Some("forge.applicability-report/1"), + "forge.authoring-gap-report-complete/1", + ), + pin( + SourceKindV3::ApplicabilityManifest, + "authoring:applicability", + Some("forge.applicability/1"), + "forge.authoring-applicability-intrinsic/1", + ), + pin( + SourceKindV3::Framework, + "authoring:framework", + None, + "forge.authoring-framework-native/1", + ), + pin( + SourceKindV3::StoredPlan, + "authoring:plan", + Some("forge.authoring-plan/1"), + "forge.authoring-plan-complete-equality/1", + ), + ]; + values.sort_by(|a, b| a.artifact_key.cmp(&b.artifact_key)); + values +} +/// Complete private edit-capable response with a valid inert proposed edit. +fn document() -> ResponseDocumentV4 { + let patch = "# Replacement text\n"; + ResponseDocumentV4 { + schema_version: "forge.review-response/4".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + response_id: id(1), + queue_id: id(9), + queue_raw_sha256: "a".repeat(64), + item_key: "whole-plan".into(), + item_id: id(8), + domain: DomainV3::AuthoringPlan, + adapter_version: ADAPTER.into(), + requested_action: RequestedAction::ReReview, + source_pins: pins(), + subject_sha256: "b".repeat(64), + context_sha256: "c".repeat(64), + policy_sha256: "d".repeat(64), + reviewer_key: "alice".into(), + reviewer_role: "approver".into(), + disposition: Disposition::Approve, + responded_at: "2026-10-01T00:00:00Z".into(), + rationale: "private reviewer evidence".into(), + abstention_reason: None, + proposed_edit: Some(ProposedEdit { + target_subject_sha256: "b".repeat(64), + patch_format: PatchFormat::FullText, + patch: patch.into(), + patch_sha256: sha256_hex(patch.as_bytes()), + }), + supersedes: None, + } +} +/// Complete test-only serialization. +fn raw(value: &ResponseDocumentV4) -> Vec { + let mut bytes = serde_json::to_vec_pretty(value).unwrap(); + bytes.push(b'\n'); + bytes +} +/// Inspect an ordinary error without Debug on private owners. +fn refusal(value: Result) -> ContractError { + value.err().expect("expected refusal") +} + +/// The typed validator admits a complete valid edit-capable response. +#[test] +fn valid_response_passes_typed_validator() { + response(&document(), &mut ContractLedger::default(), &mut NoopControl) + .expect("valid edit-capable response"); +} + +/// The closed schema refuses an unknown edit field before Serde admits the document. +#[test] +fn unknown_edit_field_is_refused_by_schema() { + let mut value: Value = serde_json::to_value(document()).unwrap(); + value["proposed_edit"]["apply_now"] = Value::Bool(true); + let mut bytes = serde_json::to_vec_pretty(&value).unwrap(); + bytes.push(b'\n'); + assert!(matches!( + refusal(decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); +} + +/// The closed schema refuses an empty patch (shape), independent of merge classification. +#[test] +fn empty_patch_is_refused_by_schema() { + let mut document = document(); + document.proposed_edit.as_mut().unwrap().patch = String::new(); + assert!(matches!( + refusal(decode_response(&raw(&document), &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); +} + +/// A wrong patch digest passes the closed shape and is left for per-response merge classification. +#[test] +fn wrong_patch_digest_passes_shape_for_merge() { + let mut document = document(); + document.proposed_edit.as_mut().unwrap().patch_sha256 = "f".repeat(64); + let bytes = raw(&document); + let read = decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl) + .expect("shape admits; merge classifies invalid-edit"); + assert!(read.document() == &document); +} diff --git a/src/review/edit_binding.rs b/src/review/edit_binding.rs new file mode 100644 index 00000000..6784927d --- /dev/null +++ b/src/review/edit_binding.rs @@ -0,0 +1,174 @@ +//! A-authored genuine Authoring Queue/3 binding over one complete native owner. +//! Every actual Queue/Response allocation stays borrowed; loaded labels confer no proof. +use super::authoring_capture::CurrentAuthoringPlanClosure; +use super::capture::authoring::RegisteredAuthoringOriginals; +use super::chain::{compare, reserved}; +use super::chain_v3::visit; +use super::decode::{ContractError, ContractLedger}; +use super::decode_v2::phase; +use super::decode_v3::{self as decode_queue_v3, DecodedV3}; +use super::decode_v4; +use super::edit_response_binding::compared_pins; +use super::hash_v3::{self, NativeProvenance}; +use super::wire_v4::{QueueDocumentV4, ResponseDocumentV4, SourceKindV3}; +use crate::workspace::preparation::WorkControl; + +/// Private pending data retaining genuine complete native owner and actual raw inputs. +/// No caller Rc/index/list/hash or Serialize/Clone/currentness flag constructor exists. +pub(crate) struct PendingEditBinding<'native> { + /// Sole complete N/S/U owner, issued by actual receiver preparation and sealing. + closure: &'native CurrentAuthoringPlanClosure, + /// Internally observed whole input Queue and ordered Response occurrence registry. + originals: RegisteredAuthoringOriginals<'native>, + /// Inert declarations decoded from the actual held Queue allocation. + queue: DecodedV3<'native, QueueDocumentV4>, + /// Every actual Response holder in original order, including duplicate occurrences. + responses: Vec>, +} +impl<'native> PendingEditBinding<'native> { + /// Borrow the genuine native owner without detaching physical lifetime. + pub(crate) fn closure(&self) -> &'native CurrentAuthoringPlanClosure { + self.closure + } + /// Borrow only the actual complete internally issued operation registry. + pub(crate) fn originals(&self) -> &RegisteredAuthoringOriginals<'native> { + &self.originals + } + /// Borrow ordinary declarations and the full actual Queue allocation. + pub(crate) fn queue(&self) -> &DecodedV3<'native, QueueDocumentV4> { + &self.queue + } + /// Borrow every decoded actual Response occurrence; never a selected subset. + pub(crate) fn responses(&self) -> &[DecodedV3<'native, ResponseDocumentV4>] { + &self.responses + } + /// Repeat exact original registrations and complete physical U with ordinary postfences. + pub(crate) fn verify_inputs( + &self, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, + ) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + self.originals.verify_review_originals(ledger, control)?; + self.closure.verify_inputs(ledger, control) + }) + } +} +/// Admit complete private native provenance descriptors from the actual owner only. +/// Returned ordinary digest is not a capability or substitute for physical U. +pub(super) fn native_digest( + closure: &CurrentAuthoringPlanClosure, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + let actual = closure.native_provenance(); + let mut rows: Vec> = reserved(actual.len(), ledger)?; + for row in actual { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::>())?; + rows.push(row); + } + hash_v3::native_provenance(&rows, ledger, control) + }) +} +/// Close full native identity/pins and all ordinary context/policy/item hashes. +fn native_queue( + closure: &CurrentAuthoringPlanClosure, + queue: &DecodedV3<'_, QueueDocumentV4>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let document = queue.document(); + if document.items.len() != 1 || document.policies.len() != 1 { + return Err(ContractError::Binding); + } + let item = &document.items[0]; + let pins = closure.source_pins(); + compared_pins(&document.source_pins, pins, ledger)?; + if document.source_pins != pins || item.source_keys.len() != pins.len() { + return Err(ContractError::Binding); + } + let mut stored_plan = None; + for (key, pin) in item.source_keys.iter().zip(pins) { + visit(ledger, control)?; + if !compare(key, &pin.artifact_key, ledger)?.is_eq() { + return Err(ContractError::Binding); + } + ledger.bytes(std::mem::size_of::())?; + if pin.kind == SourceKindV3::StoredPlan { + if stored_plan.is_some() { + return Err(ContractError::Binding); + } + stored_plan = Some(pin.raw_sha256.as_str()); + } + } + for reason in &item.context.reason_codes { + visit(ledger, control)?; + ledger.bytes(reason.len())?; + } + for subject in &item.context.related_subject_ids { + visit(ledger, control)?; + ledger.bytes(subject.len())?; + } + if item.context.reason_codes.len() != 1 + || item.context.reason_codes[0] != "authoring-plan-current" + || !item.context.related_subject_ids.is_empty() + { + return Err(ContractError::Binding); + } + let project = &closure.facts().loaded.project; + let identity = hash_v3::subject_id(&project.project_key, ledger, control)?; + let provenance = native_digest(closure, ledger, control)?; + let subject = hash_v3::subject( + &project.project_key, + &project.as_of, + &provenance, + stored_plan.ok_or(ContractError::Binding)?, + pins, + ledger, + control, + )?; + let context = hash_v3::context(pins, &item.context, ledger, control)?; + let policy = hash_v3::policy(pins, &document.policies[0], item, ledger, control)?; + let item_id = hash_v3::item_id(&document.queue_id, item, pins, ledger, control)?; + if !compare(&identity, &item.subject_id, ledger)?.is_eq() + || !compare(&subject, &item.subject_sha256, ledger)?.is_eq() + || !compare(&context, &item.context_sha256, ledger)?.is_eq() + || !compare(&policy, &item.policy_sha256, ledger)?.is_eq() + || !compare(&item_id, &item.item_id, ledger)?.is_eq() + { + return Err(ContractError::Binding); + } + Ok(()) + }) +} +/// Decode the actual Queue and every actual Response after genuine complete capture sealing. +/// Foreign/stale/unassigned/future/late ordinary evidence remains available to policy. +pub(crate) fn prepare<'native>( + closure: &'native CurrentAuthoringPlanClosure, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + closure.verify_inputs(ledger, control)?; + let originals = closure.originals()?; + originals.verify_review_originals(ledger, control)?; + let raw = originals.queue_raw().ok_or(ContractError::Binding)?; + let queue = decode_queue_v3::decode_queue(raw, ledger, control)?; + native_queue(closure, &queue, ledger, control)?; + let actual = originals.responses(); + let mut responses = reserved(actual.len(), ledger)?; + for raw in actual { + visit(ledger, control)?; + let decoded = decode_v4::decode_response(raw, ledger, control)?; + ledger.bytes(std::mem::size_of::>())?; + responses.push(decoded); + } + originals.verify_review_originals(ledger, control)?; + closure.verify_inputs(ledger, control)?; + ledger.derived(std::mem::size_of::>())?; + Ok(PendingEditBinding { closure, originals, queue, responses }) + }) +} diff --git a/src/review/edit_codec_tests.rs b/src/review/edit_codec_tests.rs new file mode 100644 index 00000000..40fe605e --- /dev/null +++ b/src/review/edit_codec_tests.rs @@ -0,0 +1,293 @@ +//! Genuine plain edit-capable /4 codec controls: proposed-edit round-trip, structural +//! refusal and the new invalid-edit recorded classification. Never native proof. +use super::{decode_dispositions, decode_response}; +use crate::hashing::sha256_hex; +use crate::review::decode::{ContractError, ContractLedger}; +use crate::review::encode_v4; +use crate::review::wire_v3::NativeModelV3; +use crate::review::wire_v4::{ + ADAPTER, Disposition, DispositionCounts, DispositionsDocumentV4, DomainV3, IDENTITY_DISCLAIMER, + ItemDisposition, ItemState, PatchFormat, ProposedEdit, RecordedCurrentness, RecordedResponse, + RequestedAction, ResponseClassification, ResponseDocumentV4, SourceKindV3, SourcePinV3, + StateCounts, UnmetSeat, +}; +use crate::workspace::preparation::NoopControl; +use serde_json::Value; + +/// Canonical plain review identities, independent of native identifiers. +fn id(n: u8) -> String { + format!("{n:08x}-1111-4111-8111-111111111111") +} +/// One ordinary source pin; a digest is asserted data only, never native truth. +fn pin(kind: SourceKindV3, _ordinal: usize) -> SourcePinV3 { + let (key, schema, profile, model, root) = match kind { + SourceKindV3::AuthorProject => ( + "authoring:project".into(), + Some("forge.author-project/1"), + "forge.author-project-intrinsic/1", + None, + None, + ), + SourceKindV3::AuthoringPack => ( + "authoring:pack".into(), + Some("forge.authoring-pack/1"), + "forge.authoring-pack-intrinsic/1", + None, + None, + ), + SourceKindV3::GapReport => ( + "authoring:gap-report".into(), + Some("forge.applicability-report/1"), + "forge.authoring-gap-report-complete/1", + None, + None, + ), + SourceKindV3::ApplicabilityManifest => ( + "authoring:applicability".into(), + Some("forge.applicability/1"), + "forge.authoring-applicability-intrinsic/1", + None, + None, + ), + SourceKindV3::Framework => ( + "authoring:framework".into(), + None, + "forge.authoring-framework-native/1", + Some(NativeModelV3::Catalog), + Some("AAAAAAAA-BBBB-4CCC-8DDD-EEEEEEEEEEEE"), + ), + SourceKindV3::StoredPlan => ( + "authoring:plan".into(), + Some("forge.authoring-plan/1"), + "forge.authoring-plan-complete-equality/1", + None, + None, + ), + _ => unreachable!("fixture uses only the six ordinary purposes"), + }; + SourcePinV3 { + artifact_key: key, + kind, + raw_sha256: "a".repeat(64), + byte_length: 17, + schema_identity: schema.map(str::to_owned), + validation_profile: profile.into(), + native_model: model, + native_root_uuid: root.map(str::to_owned), + } +} +/// The full ordinary six-purpose roster, sorted by artifact key. +fn pins() -> Vec { + let mut values = vec![ + pin(SourceKindV3::AuthorProject, 0), + pin(SourceKindV3::AuthoringPack, 0), + pin(SourceKindV3::GapReport, 0), + pin(SourceKindV3::ApplicabilityManifest, 0), + pin(SourceKindV3::Framework, 0), + pin(SourceKindV3::StoredPlan, 0), + ]; + values.sort_by(|a, b| a.artifact_key.cmp(&b.artifact_key)); + values +} +/// One inert proposed edit bound to the fixture subject, with an exact patch digest. +fn edit(patch: &str) -> ProposedEdit { + ProposedEdit { + target_subject_sha256: "b".repeat(64), + patch_format: PatchFormat::FullText, + patch: patch.into(), + patch_sha256: sha256_hex(patch.as_bytes()), + } +} +/// Complete private edit-capable response; the proposed edit is optional inert data. +fn response(proposed_edit: Option) -> ResponseDocumentV4 { + ResponseDocumentV4 { + schema_version: "forge.review-response/4".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + response_id: id(1), + queue_id: id(9), + queue_raw_sha256: "a".repeat(64), + item_key: "whole-plan".into(), + item_id: id(8), + domain: DomainV3::AuthoringPlan, + adapter_version: ADAPTER.into(), + requested_action: RequestedAction::ReReview, + source_pins: pins(), + subject_sha256: "b".repeat(64), + context_sha256: "c".repeat(64), + policy_sha256: "d".repeat(64), + reviewer_key: "alice".into(), + reviewer_role: "approver".into(), + disposition: Disposition::Approve, + responded_at: "2026-10-01T00:00:00Z".into(), + rationale: "private reviewer evidence".into(), + abstention_reason: None, + proposed_edit, + supersedes: None, + } +} +/// Complete test-only serialization; production emit/readback has separate controls. +fn raw(value: &T) -> Vec { + let mut bytes = serde_json::to_vec_pretty(value).unwrap(); + bytes.push(b'\n'); + bytes +} +/// Inspect an ordinary error without Debug on private owners. +fn refusal(value: Result) -> ContractError { + value.err().expect("expected refusal") +} + +/// A valid proposed edit round-trips byte-exactly through emit, strict decode and equality. +#[test] +fn valid_proposed_edit_round_trips() { + let document = response(Some(edit("# Replacement plan text\n"))); + let bytes = encode_v4::response(&document, &mut ContractLedger::default(), &mut NoopControl) + .expect("finite edit-capable response output"); + let read = decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl) + .expect("strict edit-capable readback"); + assert!(read.document() == &document); + assert_eq!(read.raw(), bytes.as_slice()); + assert_eq!(read.raw_sha256(), sha256_hex(&bytes)); + let edit = read.document().proposed_edit.as_ref().expect("edit retained"); + assert_eq!(edit.patch, "# Replacement plan text\n"); + assert_eq!(edit.patch_sha256, sha256_hex(edit.patch.as_bytes())); +} + +/// The null edit slot preserves the zero-edit behavior and still round-trips. +#[test] +fn null_proposed_edit_round_trips() { + let document = response(None); + let bytes = + encode_v4::response(&document, &mut ContractLedger::default(), &mut NoopControl).unwrap(); + let read = decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl).unwrap(); + assert!(read.document() == &document); + assert!(read.document().proposed_edit.is_none()); +} + +/// A patch digest that does not match the exact patch bytes still decodes: semantic edit +/// validity is a per-response merge classification (invalid-edit), not a decode refusal. +#[test] +fn wrong_patch_digest_decodes_for_merge_classification() { + let mut document = response(Some(edit("# Replacement plan text\n"))); + document.proposed_edit.as_mut().unwrap().patch_sha256 = "f".repeat(64); + let bytes = raw(&document); + let read = decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl) + .expect("malformed edit decodes; merge classifies it invalid-edit"); + assert!(read.document() == &document); +} + +/// An empty patch is structurally refused; the envelope requires nonempty bounded text. +#[test] +fn empty_patch_is_refused() { + let document = response(Some(edit(""))); + let bytes = raw(&document); + assert!(matches!( + refusal(decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); +} + +/// A patch beyond the 64 KiB bound is refused before any allocation grows. +#[test] +fn oversized_patch_is_refused() { + let document = response(Some(edit(&"x".repeat(64 * 1024 + 1)))); + let bytes = raw(&document); + assert!(matches!( + refusal(decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid | ContractError::Capacity + )); +} + +/// A wrong target hash still decodes: the binding is a per-response merge classification +/// (AC-5), not a structural decode refusal. The patch is retained as inert evidence. +#[test] +fn wrong_target_hash_decodes_for_merge_classification() { + let mut document = response(Some(edit("# Replacement plan text\n"))); + document.proposed_edit.as_mut().unwrap().target_subject_sha256 = "e".repeat(64); + let bytes = raw(&document); + let read = decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl) + .expect("wrong-target edit decodes; merge classifies it stale"); + assert_eq!( + read.document().proposed_edit.as_ref().unwrap().target_subject_sha256, + "e".repeat(64) + ); +} + +/// One recorded bundle carrying the new invalid-edit classification round-trips exactly. +fn recorded_invalid_edit() -> DispositionsDocumentV4 { + DispositionsDocumentV4 { + schema_version: "forge.review-dispositions/4".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + queue_id: id(9), + queue_raw_sha256: "a".repeat(64), + as_of: "2026-10-01T00:00:03Z".into(), + currentness: RecordedCurrentness::Unverified, + closure_generation: None, + source_pins: pins(), + responses: vec![RecordedResponse { + response_id: id(1), + raw_sha256: "a".repeat(64), + byte_length: 200, + item_key: "whole-plan".into(), + reviewer_key: "alice".into(), + reviewer_role: "approver".into(), + disposition: Disposition::Approve, + responded_at: "2026-10-01T00:00:00Z".into(), + classification: ResponseClassification::InvalidEdit, + }], + items: vec![ItemDisposition { + item_key: "whole-plan".into(), + item_id: id(8), + state: ItemState::Assigned, + reason_codes: vec!["asserted-identity-only".into()], + required_seats: 1, + met_seats: vec![], + unmet_seats: vec![UnmetSeat { role_key: "approver".into(), ordinal: 0 }], + response_ids: vec![id(1)], + dissent_ids: vec![], + blocking: false, + }], + counts: DispositionCounts { + items: 1, + response_files: 1, + unique_responses: 1, + exact_duplicates: 0, + states: StateCounts { + unassigned: 0, + assigned: 1, + in_review: 0, + conflicted: 0, + changes_requested: 0, + quorum_met: 0, + expired: 0, + stale: 0, + }, + }, + } +} + +/// The invalid-edit classification is a closed recorded value that survives emit/readback. +#[test] +fn invalid_edit_classification_round_trips() { + let document = recorded_invalid_edit(); + let bytes = + encode_v4::dispositions(&document, &mut ContractLedger::default(), &mut NoopControl) + .expect("finite recorded output"); + let read = decode_dispositions(&bytes, &mut ContractLedger::default(), &mut NoopControl) + .expect("strict recorded readback"); + assert!(read.document() == &document); + assert_eq!(read.document().responses[0].classification, ResponseClassification::InvalidEdit); + let value: Value = serde_json::from_slice(&bytes).unwrap(); + assert_eq!(value["responses"][0]["classification"], "invalid-edit"); +} + +/// The /4 response decoder refuses a /3 version token; the families stay separately closed. +#[test] +fn response_version_is_separately_closed() { + let mut document = response(None); + document.schema_version = "forge.review-response/3".into(); + let bytes = raw(&document); + assert!(matches!( + refusal(decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); +} diff --git a/src/review/edit_commands.rs b/src/review/edit_commands.rs new file mode 100644 index 00000000..1c4c7602 --- /dev/null +++ b/src/review/edit_commands.rs @@ -0,0 +1,196 @@ +//! Explicit whole-plan Authoring review operations over genuine captured originals. +//! One accepted control and ledger survive native preparation, policy evaluation, +//! complete output readback and the actual sink. Review never promotes the native plan. + +use std::io::Write; +use std::path::Path; + +use super::capture::authoring::AuthoringOperation; +use super::capture::{Pool, ReviewCapture, ReviewControl}; +use super::chain_v2::visit; +use super::commands::{CommandError, CurrentOptions}; +use super::decode::{ContractError, ContractLedger}; +use super::decode_v2::phase; +use super::{ + authoring_capture, decode_v4, edit_binding, edit_finalize, edit_response_binding, encode_v4, + merge_v4, validate, +}; +use crate::evidence_capture::CaptureRole; +use crate::workspace::preparation::WorkControl; + +/// Actual sink remains inside the invocation retaining its complete native owner. +enum Destination<'a> { + /// Reserved new local file, never overwritten. + File(&'a Path), + /// Caller-owned stream which may retain partial bytes on failure. + Writer(&'a mut dyn Write), +} + +/// Merge every actual response occurrence and publish one new recorded bundle. +pub(crate) fn merge( + options: &CurrentOptions<'_>, + output: &Path, + caller: &mut dyn WorkControl, +) -> Result<(), CommandError> { + current(options, Destination::File(output), caller) +} + +/// Write the complete current record after full native and original verification. +pub(crate) fn status( + options: &CurrentOptions<'_>, + writer: &mut dyn Write, + caller: &mut dyn WorkControl, +) -> Result<(), CommandError> { + current(options, Destination::Writer(writer), caller) +} + +/// Retain ordinary sink errors through the same original unconditional postfence. +fn command_phase( + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, + work: impl FnOnce(&mut ContractLedger, &mut dyn WorkControl) -> Result, +) -> Result { + match phase(ledger, control, |ledger, control| match work(ledger, control) { + Err(CommandError::Contract(error)) => Err(error), + ordinary => Ok(ordinary), + }) { + Ok(ordinary) => ordinary, + Err(error) => Err(error.into()), + } +} + +/// Preserve one accepted thirty-second controller and monotonic ledger through the sink. +fn current( + options: &CurrentOptions<'_>, + destination: Destination<'_>, + caller: &mut dyn WorkControl, +) -> Result<(), CommandError> { + let mut control = ReviewControl::accept(caller); + let mut ledger = ContractLedger::default(); + command_phase(&mut ledger, &mut control, |ledger, control| { + phase(ledger, control, |ledger, _| { + ledger.visits(1)?; + let time_work = options.as_of.len().checked_mul(3).ok_or_else(|| ledger.capacity())?; + ledger.bytes(time_work)?; + ledger.derived(128)?; + validate::time(options.as_of)?; + if options.responses.len() > 10_000 { + return Err(ledger.capacity()); + } + Ok(()) + })?; + let (output, operation) = match &destination { + Destination::File(path) => (Some(*path), AuthoringOperation::Merge), + Destination::Writer(_) => (None, AuthoringOperation::Status), + }; + let closure = capture_current(options, output, operation, ledger, control)?; + let binding = edit_binding::prepare(&closure, ledger, control)?; + let policy = merge_v4::prepare_policy( + binding.queue(), + binding.responses(), + options.as_of, + ledger, + control, + )?; + let current = edit_finalize::finalize(&binding, &policy, ledger, control)?; + let bytes = encode_v4::dispositions(current.document(), ledger, control)?; + let readback = decode_v4::decode_dispositions(&bytes, ledger, control)?; + encode_v4::compare_dispositions(current.document(), readback.document(), ledger, control)?; + edit_response_binding::bind_dispositions(binding.queue(), &readback, ledger, control)?; + current.verify_inputs(ledger, control)?; + match destination { + Destination::File(path) => { + publish(options.project_root, path, &bytes, ledger, control, |ledger, control| { + current.verify_inputs(ledger, control) + }) + } + Destination::Writer(writer) => command_phase(ledger, control, |ledger, control| { + ledger.bytes(bytes.len())?; + current.verify_inputs(ledger, control)?; + writer.write_all(&bytes).map_err(|_| CommandError::Output) + }), + } + }) +} + +/// Register the exact Queue and every positional Response before sealing full N/S/U. +fn capture_current( + options: &CurrentOptions<'_>, + output: Option<&Path>, + operation: AuthoringOperation, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + let mut capture = ReviewCapture::new_authoring( + options.project_root, + output.as_slice(), + operation, + ledger, + control, + )?; + capture.required( + options.queue, + CaptureRole::ReviewQueue, + Pool::Queue, + 10_485_760, + ledger, + control, + )?; + for path in options.responses { + visit(ledger, control)?; + capture.required( + path.as_path(), + CaptureRole::ReviewResponse, + Pool::Response, + 1_048_576, + ledger, + control, + )?; + } + let native = + authoring_capture::read_pending(&mut capture, options.sources, ledger, control)?; + native.finish_and_seal(capture, ledger, control) + }) +} + +/// Repeat true whole-input verification at actual native no-replace publication. +/// A late durability error or stop can accompany a complete new destination. +fn publish( + root: &Path, + output: &Path, + bytes: &[u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, + mut fence: impl FnMut(&mut ContractLedger, &mut dyn WorkControl) -> Result<(), ContractError>, +) -> Result<(), CommandError> { + command_phase(ledger, control, |ledger, control| { + ledger.bytes(bytes.len())?; + let mut cause = None; + let ordinary = crate::authoring::output::publish_new_file_guarded( + root, + output, + bytes, + || match phase(ledger, control, |ledger, control| fence(ledger, control)) { + Ok(()) => Ok(()), + Err(error) => { + cause = Some(error); + Err(crate::error::ForgeError::Authoring("review output fence refused".into())) + } + }, + ); + if let Some(error) = cause { + return Err(error.into()); + } + ordinary.map_err(|_| CommandError::Publication) + }) +} + +/// Ordinary immutable edit-capable Response/4 output from captured Queue/rationale bytes. +#[path = "edit_response.rs"] +mod response_command; +/// Publish an asserted response (optionally with an inert proposed edit). +pub(crate) use response_command::respond; + +/// Init produces the unchanged closed /3 queue; reuse the genuine authoring Init. +pub(crate) use super::authoring_commands::init; diff --git a/src/review/edit_finalize.rs b/src/review/edit_finalize.rs new file mode 100644 index 00000000..d0e5bc1d --- /dev/null +++ b/src/review/edit_finalize.rs @@ -0,0 +1,448 @@ +// A-authored actual private factory; Root alone integrates and executes it. +//! Genuine Authoring currentness finalization from the sealed captured binding. +//! A pending policy result, copied bytes or recorded digest cannot issue this owner. +//! The complete input closure stays borrowed through encoding and publication; +//! asserted review quorum never updates a native Authoring plan or reviewer authority. + +use super::chain::{compare, reserved}; +use super::chain_v3::visit; +use super::decode::{ContractError, ContractLedger}; +use super::decode_v2::phase; +use super::decode_v4; +use super::edit_binding::PendingEditBinding; +use super::hash_v3::{self, AuxiliaryOriginal, AuxiliaryPurposeV3, ResponseOriginal}; +use super::merge_v4::{ItemPolicyFactsV4, PendingPolicyEvaluationV4, TentativeStateV4}; +use super::wire::{StateCounts, UnmetSeat}; +use super::wire_v4::{ + DispositionCounts, DispositionsDocumentV4, IDENTITY_DISCLAIMER, ItemDisposition, ItemState, + MetSeat, RecordedCurrentness, RecordedResponse, SourcePinV3, +}; +use crate::workspace::preparation::WorkControl; + +/// Actual currentness-qualified record retaining the real sealed source/input borrow. +/// There is no Serialize, Deserialize, Clone, Debug or detached success constructor. +pub(crate) struct CurrentEditDispositions<'a, 'native> { + /// Internally issued native binding and its actual Queue/Response registrations. + binding: &'a PendingEditBinding<'native>, + /// Fully admitted minimized wire record; its labels are inert after serialization. + document: DispositionsDocumentV4, +} + +impl CurrentEditDispositions<'_, '_> { + /// Borrow the finite typed record without issuing another native proof owner. + pub(crate) fn document(&self) -> &DispositionsDocumentV4 { + &self.document + } + + /// Repeat the full original input and reserved-output fence on the same control. + /// Root retains this owner through its final output callback; this is not an atomic snapshot. + pub(crate) fn verify_inputs( + &self, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, + ) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| self.binding.verify_inputs(ledger, control)) + } +} + +/// Finalize only a genuinely source-bound queue and the complete actual pending cohort. +/// No caller Rc, index list, recorded current label or native-success flag is accepted. +pub(crate) fn finalize<'a, 'native>( + binding: &'a PendingEditBinding<'native>, + pending: &PendingPolicyEvaluationV4<'_>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + phase(ledger, control, |ledger, control| { + bind_originals(binding, pending, ledger, control) + })?; + let generation = generation(binding, pending, ledger, control)?; + let document = + document(pending, binding.closure().source_pins(), generation, ledger, control)?; + decode_v4::dispositions(&document, ledger, control)?; + phase(ledger, control, |ledger, control| binding.verify_inputs(ledger, control))?; + ledger.derived(std::mem::size_of::>())?; + Ok(CurrentEditDispositions { binding, document }) + }) +} + +/// Require the pending decoders to borrow every actual admitted input allocation in order. +/// The binding's registry is internally issued from this same opaque native closure. +fn bind_originals( + binding: &PendingEditBinding<'_>, + pending: &PendingPolicyEvaluationV4<'_>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let actual = binding.originals(); + binding.verify_inputs(ledger, control)?; + actual.verify_review_originals(ledger, control)?; + visit(ledger, control)?; + ledger.bytes(12 * std::mem::size_of::())?; + let counts = pending.counts(); + let actual_responses = actual.responses(); + let files = actual_responses.len(); + if pending.originals().len() != files + || binding.responses().len() != files + || counts.response_files != files + || counts.items != 1 + || pending.items().len() != 1 + || binding.queue().document().items.len() != 1 + || pending.responses().len() != counts.unique_responses + || counts.unique_responses.checked_add(counts.exact_duplicates) != Some(files) + { + return Err(ContractError::Binding); + } + let queue = actual.queue_raw().ok_or(ContractError::Binding)?; + bind_storage(pending.queue().raw(), queue, ledger)?; + bind_storage(binding.queue().raw(), queue, ledger)?; + for ((raw, original), bound) in + actual_responses.zip(pending.originals()).zip(binding.responses()) + { + visit(ledger, control)?; + bind_storage(original.raw(), raw, ledger)?; + bind_storage(bound.raw(), raw, ledger)?; + } + Ok(()) +} + +/// Check both pointer and full extent after the genuine role/cohort owner admission. +/// Equal copied bytes are deliberately refused; this predicate alone is not a file proof. +fn bind_storage( + raw: &[u8], + actual: &[u8], + ledger: &mut ContractLedger, +) -> Result<(), ContractError> { + ledger.visits(1)?; + ledger.bytes(4 * std::mem::size_of::())?; + if raw.len() != actual.len() || !std::ptr::eq(raw.as_ptr(), actual.as_ptr()) { + return Err(ContractError::Binding); + } + Ok(()) +} + +/// Hash all real registered response occurrences, preserving order and exact duplicates. +/// The /3 domain-separated digest records the bound cohort; it is never a proof constructor. +fn generation( + binding: &PendingEditBinding<'_>, + pending: &PendingPolicyEvaluationV4<'_>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + let mut rows = reserved(pending.originals().len(), ledger)?; + for original in pending.originals() { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::>())?; + rows.push(ResponseOriginal { + response_id: &original.document().response_id, + raw_sha256: original.raw_sha256(), + byte_length: u64::try_from(original.raw().len()).map_err(|_| ledger.capacity())?, + }); + } + let locator = binding.closure().locator_raw(); + ledger.bytes(locator.len())?; + ledger.derived(128)?; + let locator_hash = phase(ledger, control, |_, _| Ok(crate::hashing::sha256_hex(locator)))?; + ledger.derived(std::mem::size_of::>())?; + let auxiliary = [AuxiliaryOriginal { + purpose: AuxiliaryPurposeV3::Locator, + raw_sha256: &locator_hash, + byte_length: u64::try_from(locator.len()).map_err(|_| ledger.capacity())?, + }]; + let native = super::edit_binding::native_digest(binding.closure(), ledger, control)?; + hash_v3::closure_generation( + hash_v3::ClosureGenerationInputs { + native: &native, + pins: binding.closure().source_pins(), + queue: pending.queue().raw_sha256(), + queue_length: u64::try_from(pending.queue().raw().len()) + .map_err(|_| ledger.capacity())?, + aux: &auxiliary, + responses: &rows, + }, + ledger, + control, + ) + }) +} + +/// Copy one admitted redacted string; whole extent/work and retained payload precede growth. +fn text( + value: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + visit(ledger, control)?; + ledger.bytes(value.len())?; + ledger.derived(value.len())?; + let mut result = String::new(); + result.try_reserve_exact(value.len()).map_err(|_| ContractError::Capacity)?; + result.push_str(value); + Ok(result) +} + +/// Copy all ordered redacted references without filtering history or dissent. +fn strings( + values: &[String], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(values.len(), ledger)?; + for value in values { + ledger.bytes(std::mem::size_of::())?; + result.push(text(value, ledger, control)?); + } + Ok(result) +} + +/// Copy a nullable admitted original identity without filling an absent native UUID. +fn optional( + value: Option<&str>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + value.map(|value| text(value, ledger, control)).transpose() +} + +/// Copy the complete actual sealed source set, never a queue-supplied selected prefix. +fn source_pins( + pins: &[SourcePinV3], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(pins.len(), ledger)?; + for pin in pins { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(SourcePinV3 { + artifact_key: text(&pin.artifact_key, ledger, control)?, + kind: pin.kind, + native_model: pin.native_model, + validation_profile: text(&pin.validation_profile, ledger, control)?, + native_root_uuid: optional(pin.native_root_uuid.as_deref(), ledger, control)?, + raw_sha256: text(&pin.raw_sha256, ledger, control)?, + byte_length: pin.byte_length, + schema_identity: optional(pin.schema_identity.as_deref(), ledger, control)?, + }); + } + Ok(result) +} + +/// Preserve every distinct original classification, disposition, asserted key/role/time and pin. +fn responses( + rows: &[RecordedResponse], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(rows.len(), ledger)?; + for row in rows { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(RecordedResponse { + response_id: text(&row.response_id, ledger, control)?, + raw_sha256: text(&row.raw_sha256, ledger, control)?, + byte_length: row.byte_length, + item_key: text(&row.item_key, ledger, control)?, + reviewer_key: text(&row.reviewer_key, ledger, control)?, + reviewer_role: text(&row.reviewer_role, ledger, control)?, + disposition: row.disposition, + responded_at: text(&row.responded_at, ledger, control)?, + classification: row.classification, + }); + } + Ok(result) +} + +/// Copy every recorded matching witness; no substitute key or approval is invented. +fn met_seats( + rows: &[MetSeat], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(rows.len(), ledger)?; + for row in rows { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(MetSeat { + role_key: text(&row.role_key, ledger, control)?, + ordinal: row.ordinal, + reviewer_key: text(&row.reviewer_key, ledger, control)?, + response_id: text(&row.response_id, ledger, control)?, + }); + } + Ok(result) +} + +/// Copy every unsatisfied seat without shrinking its positive required denominator. +fn unmet_seats( + rows: &[UnmetSeat], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(rows.len(), ledger)?; + for row in rows { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(UnmetSeat { + role_key: text(&row.role_key, ledger, control)?, + ordinal: row.ordinal, + }); + } + Ok(result) +} + +/// Replace only the pending currentness limitation after real native/source admission; +/// preserve every other reason and lexical ordering, with complete compared extents. +fn current_reasons( + values: &[String], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(values.len().checked_add(1).ok_or(ContractError::Capacity)?, ledger)?; + let mut inserted = false; + let mut removed = false; + for value in values { + visit(ledger, control)?; + if compare(value, "currentness-unverified", ledger)?.is_eq() { + if removed { + return Err(ContractError::Binding); + } + removed = true; + continue; + } + let ordering = compare(value, "captured-current-sources", ledger)?; + if ordering.is_eq() { + return Err(ContractError::Binding); + } + if !inserted && ordering.is_gt() { + ledger.bytes(std::mem::size_of::())?; + result.push(text("captured-current-sources", ledger, control)?); + inserted = true; + } + ledger.bytes(std::mem::size_of::())?; + result.push(text(value, ledger, control)?); + } + if !removed { + return Err(ContractError::Binding); + } + if !inserted { + ledger.bytes(std::mem::size_of::())?; + result.push(text("captured-current-sources", ledger, control)?); + } + Ok(result) +} + +/// Convert pending states only inside the genuine currentness-gated constructor. +/// Quorum remains asserted review policy, never a native domain approval transition. +fn item_state(value: TentativeStateV4) -> ItemState { + match value { + TentativeStateV4::Unassigned => ItemState::Unassigned, + TentativeStateV4::Assigned => ItemState::Assigned, + TentativeStateV4::InReview => ItemState::InReview, + TentativeStateV4::Conflicted => ItemState::Conflicted, + TentativeStateV4::ChangesRequested => ItemState::ChangesRequested, + TentativeStateV4::SeatsFilled => ItemState::QuorumMet, + TentativeStateV4::Expired => ItemState::Expired, + TentativeStateV4::BindingStale => ItemState::Stale, + } +} + +/// Copy every item/witness/reference/dissent fact; only the genuine gate supplies public state. +fn items( + rows: &[ItemPolicyFactsV4], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(rows.len(), ledger)?; + for row in rows { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(ItemDisposition { + item_key: text(&row.item_key, ledger, control)?, + item_id: text(&row.item_id, ledger, control)?, + state: item_state(row.tentative_state), + reason_codes: current_reasons(&row.reason_codes, ledger, control)?, + required_seats: row.required_seats, + met_seats: met_seats(&row.met_seats, ledger, control)?, + unmet_seats: unmet_seats(&row.unmet_seats, ledger, control)?, + response_ids: strings(&row.response_ids, ledger, control)?, + dissent_ids: strings(&row.dissent_ids, ledger, control)?, + blocking: row.blocking, + }); + } + Ok(result) +} + +/// Checked complete state counters, preserving all zeros and never deriving a winning vote. +fn state_counts( + rows: &[ItemDisposition], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + ledger.bytes(std::mem::size_of::())?; + let mut result = StateCounts { + unassigned: 0, + assigned: 0, + in_review: 0, + conflicted: 0, + changes_requested: 0, + quorum_met: 0, + expired: 0, + stale: 0, + }; + for row in rows { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::() + std::mem::size_of::())?; + let slot = match row.state { + ItemState::Unassigned => &mut result.unassigned, + ItemState::Assigned => &mut result.assigned, + ItemState::InReview => &mut result.in_review, + ItemState::Conflicted => &mut result.conflicted, + ItemState::ChangesRequested => &mut result.changes_requested, + ItemState::QuorumMet => &mut result.quorum_met, + ItemState::Expired => &mut result.expired, + ItemState::Stale => &mut result.stale, + }; + *slot = slot.checked_add(1).ok_or(ContractError::Capacity)?; + } + Ok(result) +} + +/// Build the complete redacted wire record under the same monotonic logical payload cap. +fn document( + pending: &PendingPolicyEvaluationV4<'_>, + pins: &[SourcePinV3], + generation: String, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + ledger.bytes(std::mem::size_of::())?; + ledger.derived(std::mem::size_of::())?; + let items = items(pending.items(), ledger, control)?; + let states = state_counts(&items, ledger, control)?; + let counts = pending.counts(); + Ok(DispositionsDocumentV4 { + schema_version: text("forge.review-dispositions/4", ledger, control)?, + identity_disclaimer: text(IDENTITY_DISCLAIMER, ledger, control)?, + queue_id: text(&pending.queue().document().queue_id, ledger, control)?, + queue_raw_sha256: text(pending.queue().raw_sha256(), ledger, control)?, + as_of: text(pending.as_of(), ledger, control)?, + currentness: RecordedCurrentness::RecordedCurrent, + closure_generation: Some(generation), + source_pins: source_pins(pins, ledger, control)?, + responses: responses(pending.responses(), ledger, control)?, + items, + counts: DispositionCounts { + items: u32::try_from(counts.items).map_err(|_| ContractError::Capacity)?, + response_files: u32::try_from(counts.response_files) + .map_err(|_| ContractError::Capacity)?, + unique_responses: u32::try_from(counts.unique_responses) + .map_err(|_| ContractError::Capacity)?, + exact_duplicates: u32::try_from(counts.exact_duplicates) + .map_err(|_| ContractError::Capacity)?, + states, + }, + }) +} diff --git a/src/review/edit_merge_tests.rs b/src/review/edit_merge_tests.rs new file mode 100644 index 00000000..45def083 --- /dev/null +++ b/src/review/edit_merge_tests.rs @@ -0,0 +1,349 @@ +// Genuine edit-capable /4 merge controls over the complete native fixture: AC-5 +// wrong-target classification, invalid-edit classification, the never-applied +// guarantee (G-4) and a valid proposed-edit round-trip through the full pipeline. +// Root alone executes these; no constructed lease/currentness/approval token is accepted. +use super::*; +use crate::hashing::sha256_hex; +use crate::review::wire_v3::*; +use crate::review::wire_v4::{DispositionsDocumentV4, PatchFormat, ProposedEdit, ResponseDocumentV4}; +use crate::review::{ + decode_v4, edit_binding, edit_finalize, edit_response_binding, encode_v3, encode_v4, + hash_v3, merge_v4, +}; + +/// Canonical review UUID; this is never the native project key. +fn review_id(n: u8) -> String { + format!("{n:08x}-1111-4111-8111-111111111111") +} +/// Test-only full ordinary typed copy, never a native owner constructor. +fn data_copy(value: &S) -> T { + serde_json::from_value(serde_json::to_value(value).unwrap()).unwrap() +} +/// Reframe ordinary policy/context/item fields after an explicit fixture declaration change. +fn reframe(queue: &mut QueueDocumentV3) { + let mut ledger = ContractLedger::default(); + let mut control = NoopControl; + let item = &mut queue.items[0]; + item.source_keys = queue.source_pins.iter().map(|p| p.artifact_key.clone()).collect(); + item.context_sha256 = + hash_v3::context(&queue.source_pins, &item.context, &mut ledger, &mut control).unwrap(); + item.policy_sha256 = + hash_v3::policy(&queue.source_pins, &queue.policies[0], item, &mut ledger, &mut control) + .unwrap(); + item.item_id = + hash_v3::item_id(&queue.queue_id, item, &queue.source_pins, &mut ledger, &mut control) + .unwrap(); +} +/// Derive the ordinary /3 Queue from a genuinely prepared Init owner. The edit-capable +/// family reuses the unchanged closed /3 queue shape; only responses gain an edit slot. +fn native_queue(owner: &CurrentAuthoringPlanClosure) -> QueueDocumentV3 { + let mut ledger = ContractLedger::default(); + let mut control = NoopControl; + let pins = data_copy(owner.source_pins()); + let provenance: Vec<_> = owner.native_provenance().collect(); + let digest = hash_v3::native_provenance(&provenance, &mut ledger, &mut control).unwrap(); + let project = &owner.facts().loaded.project; + let stored = owner.source_pins().iter().find(|p| p.kind == SourceKindV3::StoredPlan).unwrap(); + let subject = hash_v3::subject( + &project.project_key, + &project.as_of, + &digest, + &stored.raw_sha256, + owner.source_pins(), + &mut ledger, + &mut control, + ) + .unwrap(); + let identity = hash_v3::subject_id(&project.project_key, &mut ledger, &mut control).unwrap(); + let mut queue = QueueDocumentV3 { + schema_version: "forge.review-queue/3".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + sensitivity: Sensitivity::IdsAndHashes, + queue_id: review_id(50), + created_at: "2026-09-08T02:00:00Z".into(), + source_pins: pins, + roles: vec![RoleDefinition { key: "approver".into() }], + reviewers: vec![ + Reviewer { key: "alice".into(), role_keys: vec!["approver".into()] }, + Reviewer { key: "bob".into(), role_keys: vec!["approver".into()] }, + ], + policies: vec![ReviewPolicy { + key: "review".into(), + seats: vec![SeatRequirement { role_key: "approver".into(), count: 1 }], + substitutions: vec![], + abstention_rule: AbstentionRule::Nonapproving, + empty_abstention_reasons: vec![], + author_separation: AuthorSeparation::DeclaredKeys, + }], + items: vec![ReviewItemV3 { + key: "whole-plan".into(), + item_id: String::new(), + domain: DomainV3::AuthoringPlan, + adapter_version: ADAPTER.into(), + requested_action: RequestedAction::ReReview, + subject_id: identity, + subject_sha256: subject, + source_keys: vec![], + context: ContextSnapshot { + reason_codes: vec!["authoring-plan-current".into()], + related_subject_ids: vec![], + }, + context_sha256: String::new(), + policy_key: "review".into(), + policy_sha256: String::new(), + author_keys: vec!["author".into()], + assignments: vec![ + Assignment { reviewer_key: "alice".into(), role_key: "approver".into() }, + Assignment { reviewer_key: "bob".into(), role_key: "approver".into() }, + ], + due_at: None, + allowed_dispositions: vec![ + Disposition::Approve, + Disposition::Reject, + Disposition::RequestChanges, + Disposition::Abstain, + Disposition::Superseded, + ], + }], + }; + reframe(&mut queue); + queue +} +/// Genuine complete fixture, real Init owner, actual Queue bytes and their original digest. +fn fixture() -> (Fixture, QueueDocumentV3, Vec) { + let f = Fixture::new(false, false); + originals(&f); + let owner = + init(&f, &mut ContractLedger::default(), &mut NoopControl).expect("actual Init closure"); + let queue = native_queue(&owner); + let raw = save_queue(&f, &queue); + (f, queue, raw) +} +/// Persist the genuine complete Queue original and return its exact bytes. +fn save_queue(f: &Fixture, queue: &QueueDocumentV3) -> Vec { + let raw = + encode_v3::queue(queue, &mut ContractLedger::default(), &mut NoopControl).unwrap(); + std::fs::write(f.root.join("queue.json"), &raw).unwrap(); + raw +} +/// One inert proposed edit bound to a target subject, with an exact patch digest. +fn edit(target: &str, patch: &str) -> ProposedEdit { + ProposedEdit { + target_subject_sha256: target.into(), + patch_format: PatchFormat::FullText, + patch: patch.into(), + patch_sha256: sha256_hex(patch.as_bytes()), + } +} +/// Complete edit-capable response bound to the actual Queue original. +fn response( + queue: &QueueDocumentV3, + raw: &[u8], + n: u8, + key: &str, + proposed_edit: Option, +) -> ResponseDocumentV4 { + let item = &queue.items[0]; + ResponseDocumentV4 { + schema_version: "forge.review-response/4".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + response_id: review_id(n), + queue_id: queue.queue_id.clone(), + queue_raw_sha256: sha256_hex(raw), + item_key: item.key.clone(), + item_id: item.item_id.clone(), + domain: item.domain, + adapter_version: item.adapter_version.clone(), + requested_action: item.requested_action, + source_pins: data_copy(&queue.source_pins), + subject_sha256: item.subject_sha256.clone(), + context_sha256: item.context_sha256.clone(), + policy_sha256: item.policy_sha256.clone(), + reviewer_key: key.into(), + reviewer_role: "approver".into(), + disposition: Disposition::Approve, + responded_at: "2026-09-08T02:01:00Z".into(), + rationale: "Private rationale must stay out of public dispositions".into(), + abstention_reason: None, + proposed_edit, + supersedes: None, + } +} +/// Persist genuine finite edit-capable Response bytes; every decode uses its original ledger. +fn save_response(f: &Fixture, path: &str, document: &ResponseDocumentV4) -> Vec { + let raw = + encode_v4::response(document, &mut ContractLedger::default(), &mut NoopControl).unwrap(); + std::fs::write(f.root.join(path), &raw).unwrap(); + raw +} +/// Capture exactly the maintained complete native closure and every declared Response occurrence. +fn hold( + f: &Fixture, + paths: &[&str], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> CurrentAuthoringPlanClosure { + let mut capture = begin(f, AuthoringOperation::Merge, ledger, control); + let pending = receiver::read_pending(&mut capture, Path::new("locator.json"), ledger, control) + .unwrap(); + capture + .required( + Path::new("queue.json"), + CaptureRole::ReviewQueue, + Pool::Queue, + 10 * 1024 * 1024, + ledger, + control, + ) + .unwrap(); + for path in paths { + capture + .required( + Path::new(path), + CaptureRole::ReviewResponse, + Pool::Response, + 1024 * 1024, + ledger, + control, + ) + .unwrap(); + } + pending.finish_and_seal(capture, ledger, control).unwrap() +} +/// Genuine complete merge: bind, evaluate policy, finalize, encode, strict readback and U fence. +/// Returns the recorded bundle and the pending evaluation for classification assertions. +fn merge( + f: &Fixture, + paths: &[&str], +) -> (DispositionsDocumentV4, Vec) { + let mut ledger = ContractLedger::default(); + let mut caller = NoopControl; + let mut control = ReviewControl::accept(&mut caller); + let owner = hold(f, paths, &mut ledger, &mut control); + let bound = edit_binding::prepare(&owner, &mut ledger, &mut control).unwrap(); + let pending = merge_v4::prepare_policy( + bound.queue(), + bound.responses(), + "2026-09-08T02:10:00Z", + &mut ledger, + &mut control, + ) + .unwrap(); + let classes: Vec<_> = pending.responses().iter().map(|r| r.classification).collect(); + let current = edit_finalize::finalize(&bound, &pending, &mut ledger, &mut control).unwrap(); + let raw = encode_v4::dispositions(current.document(), &mut ledger, &mut control).unwrap(); + let read = decode_v4::decode_dispositions(&raw, &mut ledger, &mut control).unwrap(); + encode_v4::compare_dispositions(current.document(), read.document(), &mut ledger, &mut control) + .unwrap(); + edit_response_binding::bind_dispositions(bound.queue(), &read, &mut ledger, &mut control) + .unwrap(); + current.verify_inputs(&mut ledger, &mut control).unwrap(); + (data_copy(read.document()), classes) +} + +/// AC-5: a proposed edit bound to a different subject is classified stale on that response, +/// the merge continues, and a clean response from another reviewer still fills the seat. +#[test] +fn wrong_target_hash_is_stale_and_merge_continues() { + let (f, q, raw) = fixture(); + let wrong = "e".repeat(64); + assert_ne!(wrong, q.items[0].subject_sha256); + save_response( + &f, + "a.json", + &response(&q, &raw, 1, "alice", Some(edit(&wrong, "# stale target patch\n"))), + ); + save_response(&f, "b.json", &response(&q, &raw, 2, "bob", None)); + let (recorded, classes) = merge(&f, &["a.json", "b.json"]); + assert_eq!(classes, vec![ResponseClassification::Stale, ResponseClassification::Current]); + assert_eq!(recorded.responses[0].classification, ResponseClassification::Stale); + assert_eq!(recorded.responses[1].classification, ResponseClassification::Current); + // The clean response still satisfies the declared seat; the stale edit never blocks it. + assert_eq!(recorded.items[0].state, ItemState::QuorumMet); + assert_eq!(recorded.items[0].met_seats.len(), 1); + assert_eq!(recorded.items[0].met_seats[0].reviewer_key, "bob"); +} + +/// A malformed edit envelope (wrong patch digest) is classified invalid-edit on that response; +/// the merge continues and a clean response from another reviewer still fills the seat. +#[test] +fn invalid_edit_is_classified_and_merge_continues() { + let (f, q, raw) = fixture(); + let mut bad = edit(&q.items[0].subject_sha256, "# replacement text\n"); + bad.patch_sha256 = "f".repeat(64); // digest does not match the patch bytes + save_response(&f, "a.json", &response(&q, &raw, 1, "alice", Some(bad))); + save_response(&f, "b.json", &response(&q, &raw, 2, "bob", None)); + let (recorded, classes) = merge(&f, &["a.json", "b.json"]); + assert_eq!(classes, vec![ResponseClassification::InvalidEdit, ResponseClassification::Current]); + assert_eq!(recorded.responses[0].classification, ResponseClassification::InvalidEdit); + assert_eq!(recorded.responses[1].classification, ResponseClassification::Current); + // The clean response still satisfies the declared seat; the invalid edit never supplies one. + assert_eq!(recorded.items[0].state, ItemState::QuorumMet); + assert_eq!(recorded.items[0].met_seats.len(), 1); + assert_eq!(recorded.items[0].met_seats[0].reviewer_key, "bob"); +} + +/// G-4 never-applied: a valid proposed edit is retained as inert evidence and the complete +/// native source originals are byte-for-byte unchanged after the full merge pipeline. +#[test] +fn proposed_edit_is_never_applied_to_sources() { + let (f, q, raw) = fixture(); + let before: Vec<(String, Vec)> = ["project.json", "stored-plan.json", "locator.json"] + .iter() + .map(|name| ((*name).to_owned(), std::fs::read(f.root.join(name)).unwrap())) + .collect(); + let patch = "# Proposed replacement plan text — inert until a human promotes it\n"; + save_response( + &f, + "a.json", + &response(&q, &raw, 1, "alice", Some(edit(&q.items[0].subject_sha256, patch))), + ); + let (recorded, classes) = merge(&f, &["a.json"]); + assert_eq!(classes, vec![ResponseClassification::Current]); + assert_eq!(recorded.items[0].state, ItemState::QuorumMet); + // Every native source original is byte-for-byte unchanged: the patch was never applied. + for (name, bytes) in &before { + assert_eq!(&std::fs::read(f.root.join(name)).unwrap(), bytes, "source {name} mutated"); + } + // The recorded public bundle carries no patch text: edits stay private inert evidence. + let public = serde_json::to_string(&recorded).unwrap(); + assert!(!public.contains("Proposed replacement plan text")); +} + +/// A valid proposed edit round-trips through the complete pipeline: respond bytes decode, +/// bind to the actual Queue, merge to quorum, and the recorded bundle readback is exact. +#[test] +fn valid_proposed_edit_round_trips_through_merge() { + let (f, q, raw) = fixture(); + let patch = "# Valid replacement plan text\n"; + let document = response(&q, &raw, 1, "alice", Some(edit(&q.items[0].subject_sha256, patch))); + let response_raw = save_response(&f, "a.json", &document); + // The emitted response decodes strictly and retains the exact inert edit. + let read = decode_v4::decode_response( + &response_raw, + &mut ContractLedger::default(), + &mut NoopControl, + ) + .unwrap(); + assert!(read.document() == &document); + assert_eq!(read.document().proposed_edit.as_ref().unwrap().patch, patch); + let (recorded, classes) = merge(&f, &["a.json"]); + assert_eq!(classes, vec![ResponseClassification::Current]); + assert_eq!(recorded.items[0].state, ItemState::QuorumMet); + assert_eq!(recorded.items[0].met_seats[0].reviewer_key, "alice"); + assert_eq!(recorded.counts.unique_responses, 1); +} + +/// The zero-edit contract holds: a /4 response with a null edit merges exactly like /3, +/// and the edit-capable family never mutates the native plan or grants domain approval. +#[test] +fn null_edit_preserves_zero_edit_quorum_contract() { + let (f, q, raw) = fixture(); + save_response(&f, "a.json", &response(&q, &raw, 1, "alice", None)); + save_response(&f, "b.json", &response(&q, &raw, 2, "bob", None)); + let (recorded, classes) = merge(&f, &["a.json", "b.json"]); + assert_eq!(classes, vec![ResponseClassification::Current, ResponseClassification::Current]); + assert_eq!(recorded.items[0].state, ItemState::QuorumMet); + assert_eq!(recorded.currentness, RecordedCurrentness::RecordedCurrent); + assert!(recorded.closure_generation.is_some()); +} diff --git a/src/review/edit_response.rs b/src/review/edit_response.rs new file mode 100644 index 00000000..391ee0ec --- /dev/null +++ b/src/review/edit_response.rs @@ -0,0 +1,208 @@ +//! Ordinary Authoring Response/3 from complete held Queue and private rationale. +//! Assertions preserve recorded bindings and never issue native currentness. +use super::{command_phase, publish}; +use crate::evidence_capture::CaptureRole; +use crate::review::capture::{HeldReviewInputs, Pool, ReviewCapture, ReviewControl}; +use crate::review::chain::{compare, reserved}; +use crate::review::chain_v2::visit; +use crate::review::commands::{CommandError, RespondOptions}; +use crate::review::decode::{ContractError, ContractLedger}; +use crate::review::decode_v2::phase; +use crate::review::decode_v3::{self as decode_queue_v3, DecodedV3}; +use crate::review::decode_v4; +use crate::review::wire_v4::{ + IDENTITY_DISCLAIMER, PatchFormat, ProposedEdit, QueueDocumentV4, RESPONSE_VERSION, + ResponseDocumentV4, SourcePinV3, SupersessionReference, +}; +use crate::review::{edit_response_binding, encode_v4}; +use crate::workspace::preparation::WorkControl; + +/// Publish one immutable assertion after complete strict recorded binding/readback. +pub(crate) fn respond( + options: &RespondOptions<'_>, + caller: &mut dyn WorkControl, +) -> Result<(), CommandError> { + let mut control = ReviewControl::accept(caller); + let mut ledger = ContractLedger::default(); + command_phase(&mut ledger, &mut control, |ledger, control| { + let mut capture = + ReviewCapture::new(options.project_root, &[options.output], ledger, control)?; + let queue_index = capture.required( + options.queue, + CaptureRole::ReviewQueue, + Pool::Queue, + 10_485_760, + ledger, + control, + )?; + let rationale_index = capture.required( + options.rationale_file, + CaptureRole::ReviewPrivateConfig, + Pool::Auxiliary, + 8_192, + ledger, + control, + )?; + let held = phase(ledger, control, |ledger, _| { + ledger.derived(std::mem::size_of::())?; + Ok(capture.finish()) + })?; + let queue = decode_queue_v3::decode_queue(held.bytes(queue_index)?, ledger, control)?; + let response = + build_response(options, &queue, held.bytes(rationale_index)?, ledger, control)?; + let bytes = encode_v4::response(&response, ledger, control)?; + let readback = decode_v4::decode_response(&bytes, ledger, control)?; + encode_v4::compare_responses(&response, readback.document(), ledger, control)?; + edit_response_binding::bind_response(&queue, &readback, ledger, control)?; + held.verify_inputs(ledger, control)?; + publish(options.project_root, options.output, &bytes, ledger, control, |ledger, control| { + held.verify_inputs(ledger, control) + }) + }) +} + +/// Copy a full bounded field after admitting its complete work/payload representation. +fn copied( + value: &str, + maximum: usize, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + visit(ledger, control)?; + ledger.bytes(value.len())?; + if value.len() > maximum { + return Err(ContractError::Invalid); + } + let retained_extent = + value.len().checked_add(std::mem::size_of::()).ok_or_else(|| ledger.capacity())?; + ledger.derived(retained_extent)?; + let mut result = String::new(); + result.try_reserve_exact(value.len()).map_err(|_| ledger.capacity())?; + result.push_str(value); + Ok(result) +} + +/// Preserve all eight exact pin fields and every explicit nullable value in order. +fn pins( + input: &[SourcePinV3], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(input.len(), ledger)?; + for pin in input { + visit(ledger, control)?; + ledger.bytes(std::mem::size_of::())?; + result.push(SourcePinV3 { + artifact_key: copied(&pin.artifact_key, 128, ledger, control)?, + kind: pin.kind, + raw_sha256: copied(&pin.raw_sha256, 64, ledger, control)?, + byte_length: pin.byte_length, + schema_identity: pin + .schema_identity + .as_deref() + .map(|value| copied(value, 128, ledger, control)) + .transpose()?, + validation_profile: copied(&pin.validation_profile, 128, ledger, control)?, + native_model: pin.native_model, + native_root_uuid: pin + .native_root_uuid + .as_deref() + .map(|value| copied(value, 128, ledger, control)) + .transpose()?, + }); + } + Ok(result) +} + +/// Derive recorded correlations only from the actual strict Queue original. +fn build_response( + options: &RespondOptions<'_>, + queue: &DecodedV3<'_, QueueDocumentV4>, + rationale: &[u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + if rationale.len() > 8_192 { + return Err(ledger.capacity()); + } + ledger.bytes(rationale.len())?; + let rationale = std::str::from_utf8(rationale).map_err(|_| ContractError::Invalid)?; + ledger.bytes(options.item_key.len())?; + if options.item_key.len() > 128 { + return Err(ContractError::Invalid); + } + let document = queue.document(); + let mut selected = None; + for item in &document.items { + visit(ledger, control)?; + if compare(&item.key, options.item_key, ledger)?.is_eq() { + selected = Some(item); + } + } + let item = selected.ok_or(ContractError::Binding)?; + ledger.bytes(std::mem::size_of::())?; + ledger.derived(std::mem::size_of::())?; + let supersedes = options + .supersedes + .as_ref() + .map(|prior| -> Result { + ledger.bytes(std::mem::size_of::())?; + ledger.derived(std::mem::size_of::())?; + Ok(SupersessionReference { + response_id: copied(prior.response_id, 36, ledger, control)?, + raw_sha256: copied(prior.raw_sha256, 64, ledger, control)?, + }) + }) + .transpose()?; + let proposed_edit = match options.proposed_patch { + None => None, + Some(patch) => { + if patch.len() > 64 * 1024 { + return Err(ledger.capacity()); + } + ledger.bytes(patch.len())?; + let patch = std::str::from_utf8(patch).map_err(|_| ContractError::Invalid)?; + let patch_sha256 = phase(ledger, control, |_, _| { + Ok(crate::hashing::sha256_hex(patch.as_bytes())) + })?; + ledger.derived(std::mem::size_of::())?; + Some(ProposedEdit { + target_subject_sha256: copied(&item.subject_sha256, 64, ledger, control)?, + patch_format: PatchFormat::FullText, + patch: copied(patch, 64 * 1024, ledger, control)?, + patch_sha256, + }) + } + }; + let response = ResponseDocumentV4 { + schema_version: copied(RESPONSE_VERSION, 128, ledger, control)?, + identity_disclaimer: copied(IDENTITY_DISCLAIMER, 128, ledger, control)?, + response_id: copied(options.response_id, 36, ledger, control)?, + queue_id: copied(&document.queue_id, 36, ledger, control)?, + queue_raw_sha256: copied(queue.raw_sha256(), 64, ledger, control)?, + item_key: copied(&item.key, 128, ledger, control)?, + item_id: copied(&item.item_id, 36, ledger, control)?, + domain: item.domain, + adapter_version: copied(&item.adapter_version, 128, ledger, control)?, + requested_action: item.requested_action, + source_pins: pins(&document.source_pins, ledger, control)?, + subject_sha256: copied(&item.subject_sha256, 64, ledger, control)?, + context_sha256: copied(&item.context_sha256, 64, ledger, control)?, + policy_sha256: copied(&item.policy_sha256, 64, ledger, control)?, + reviewer_key: copied(options.reviewer_key, 128, ledger, control)?, + reviewer_role: copied(options.reviewer_role, 128, ledger, control)?, + disposition: options.disposition, + responded_at: copied(options.responded_at, 20, ledger, control)?, + rationale: copied(rationale, 8_192, ledger, control)?, + abstention_reason: options + .abstention_reason + .map(|value| copied(value, 128, ledger, control)) + .transpose()?, + proposed_edit, + supersedes, + }; + decode_v4::response(&response, ledger, control)?; + Ok(response) + }) +} diff --git a/src/review/edit_response_binding.rs b/src/review/edit_response_binding.rs new file mode 100644 index 00000000..d4811440 --- /dev/null +++ b/src/review/edit_response_binding.rs @@ -0,0 +1,412 @@ +//! A-authored ordinary /3 binding and complete raw-original relation. +//! These declarations/correlations authenticate no reviewer or native currentness. +use super::decode::{ContractError, ContractLedger, OriginalRelation}; +use super::decode_v2::phase; +use super::decode_v4::{self, DecodedV3}; +use super::wire_v4::{ + Disposition, DispositionsDocumentV4, ProposedEdit, QueueDocumentV4, ResponseDocumentV4, + ReviewItemV3, ReviewPolicy, SourcePinV3, +}; +use crate::workspace::preparation::WorkControl; + +/// Charge every actual operand before inspecting or comparing full strings. +fn strings(values: &[&str], ledger: &mut ContractLedger) -> Result<(), ContractError> { + ledger.visits(values.len())?; + for value in values { + ledger.bytes(value.len())?; + } + Ok(()) +} +/// Exact ordinary equality after both complete original UTF-8 extents are admitted. +fn same(left: &str, right: &str, ledger: &mut ContractLedger) -> Result { + strings(&[left, right], ledger)?; + Ok(left == right) +} +/// Exhaustive eight-field operand accounting before any pin-list equality. +pub(super) fn compared_pins( + left: &[SourcePinV3], + right: &[SourcePinV3], + ledger: &mut ContractLedger, +) -> Result<(), ContractError> { + for pins in [left, right] { + ledger.visits(pins.len())?; + for pin in pins { + let SourcePinV3 { + artifact_key, + kind: _, + raw_sha256, + byte_length: _, + schema_identity, + validation_profile, + native_model: _, + native_root_uuid, + } = pin; + strings( + &[ + artifact_key, + raw_sha256, + validation_profile, + schema_identity.as_deref().unwrap_or(""), + native_root_uuid.as_deref().unwrap_or(""), + ], + ledger, + )?; + ledger.bytes(64)?; + } + } + Ok(()) +} +/// All declared reviewer-role/author/assignment/substitution rows remain full operands. +fn eligible( + queue: &QueueDocumentV4, + item: &ReviewItemV3, + policy: &ReviewPolicy, + reviewer_key: &str, + reviewer_role: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + let mut membership = false; + for reviewer in &queue.reviewers { + super::decode_v2::checkpoint(ledger, control)?; + let key = same(&reviewer.key, reviewer_key, ledger)?; + for role in &reviewer.role_keys { + let matched = same(role, reviewer_role, ledger)?; + membership |= key && matched; + } + } + let mut author = false; + for key in &item.author_keys { + author |= same(key, reviewer_key, ledger)?; + } + let mut assigned = false; + for row in &item.assignments { + super::decode_v2::checkpoint(ledger, control)?; + let key = same(&row.reviewer_key, reviewer_key, ledger)?; + let role = same(&row.role_key, reviewer_role, ledger)?; + assigned |= key && role; + } + for row in &policy.substitutions { + super::decode_v2::checkpoint(ledger, control)?; + let key = same(&row.reviewer_key, reviewer_key, ledger)?; + let role = same(&row.asserted_role, reviewer_role, ledger)?; + assigned |= key && role; + } + Ok(membership && !author && assigned) +} +/// Maximum bounded proposed patch text, in UTF-8 bytes (PRD 068 M-10 envelope). +const MAX_PATCH_BYTES: usize = 64 * 1024; + +/// Structural edit-envelope syntax: bounded nonempty patch, exact digest grammar and +/// exact patch-byte integrity. Deliberately does NOT check the target binding, so a +/// wrong-target edit still decodes and is classified per response at merge (AC-5). +pub(crate) fn edit_structural( + edit: &ProposedEdit, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + strings(&[&edit.target_subject_sha256, &edit.patch, &edit.patch_sha256], ledger)?; + if edit.patch.is_empty() || edit.patch.len() > MAX_PATCH_BYTES { + return Ok(false); + } + for value in [&edit.target_subject_sha256, &edit.patch_sha256] { + if value.len() != 64 + || !value.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) + { + return Ok(false); + } + } + let digest = + phase(ledger, control, |_, _| Ok(crate::hashing::sha256_hex(edit.patch.as_bytes())))?; + same(&digest, &edit.patch_sha256, ledger) + }) +} + +/// Complete proposed-edit validity: structural syntax plus the exact target binding. +/// A wrong target is stale (handled by the merge); a malformed envelope is invalid-edit. +pub(crate) fn edit_well_formed( + edit: &ProposedEdit, + subject_sha256: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, control| { + if !same(&edit.target_subject_sha256, subject_sha256, ledger)? { + return Ok(false); + } + edit_structural(edit, ledger, control) + }) +} + +/// Bind complete separately typed assertions to the actual raw Queue snapshot. +/// Merge keeps foreign/stale history and calls this only at the eligibility phase. +pub(crate) fn bind_response( + queue: &DecodedV3<'_, QueueDocumentV4>, + response: &DecodedV3<'_, ResponseDocumentV4>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let queue_doc = queue.document(); + let response = response.document(); + let item = queue_doc.items.first().ok_or(ContractError::Binding)?; + let policy = queue_doc.policies.first().ok_or(ContractError::Binding)?; + compared_pins(&response.source_pins, &queue_doc.source_pins, ledger)?; + strings( + &[ + &response.queue_id, + &queue_doc.queue_id, + &response.queue_raw_sha256, + queue.raw_sha256(), + &response.item_key, + &item.key, + &response.item_id, + &item.item_id, + &response.adapter_version, + &item.adapter_version, + &response.subject_sha256, + &item.subject_sha256, + &response.context_sha256, + &item.context_sha256, + &response.policy_sha256, + &item.policy_sha256, + &response.responded_at, + &queue_doc.created_at, + ], + ledger, + )?; + ledger.bytes(32)?; + if response.queue_id != queue_doc.queue_id + || response.queue_raw_sha256 != queue.raw_sha256() + || response.item_key != item.key + || response.item_id != item.item_id + || response.domain != item.domain + || response.adapter_version != item.adapter_version + || response.requested_action != item.requested_action + || response.source_pins != queue_doc.source_pins + || response.subject_sha256 != item.subject_sha256 + || response.context_sha256 != item.context_sha256 + || response.policy_sha256 != item.policy_sha256 + || response.responded_at < queue_doc.created_at + { + return Err(ContractError::Binding); + } + if !eligible( + queue_doc, + item, + policy, + &response.reviewer_key, + &response.reviewer_role, + ledger, + control, + )? { + return Err(ContractError::Binding); + } + ledger.bytes(response.rationale.len())?; + if response.disposition == Disposition::Abstain && response.rationale.trim().is_empty() { + let mut permitted = false; + for reason in &policy.empty_abstention_reasons { + super::decode_v2::checkpoint(ledger, control)?; + strings(&[reason, response.abstention_reason.as_deref().unwrap_or("")], ledger)?; + permitted |= response.abstention_reason.as_deref() == Some(reason.as_str()); + } + if !permitted { + return Err(ContractError::Binding); + } + } + Ok(()) + }) +} +/// Same identity and equal complete raw bytes are the only exact duplicate relation. +pub(crate) fn original_relation( + left: &DecodedV3<'_, ResponseDocumentV4>, + right: &DecodedV3<'_, ResponseDocumentV4>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + phase(ledger, control, |ledger, _| { + if !same(&left.document().response_id, &right.document().response_id, ledger)? { + return Ok(OriginalRelation::DifferentIdentity); + } + let extent = + left.raw().len().checked_add(right.raw().len()).ok_or_else(|| ledger.capacity())?; + ledger.bytes(extent)?; + Ok(if left.raw() == right.raw() { + OriginalRelation::ExactDuplicate + } else { + OriginalRelation::IdentityConflict + }) + }) +} +/// Bind exactly the matched seat, rather than eligibility for some other seat. +fn seat_eligible( + queue: &QueueDocumentV4, + item: &ReviewItemV3, + policy: &ReviewPolicy, + asserted: (&str, &str, &str), + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + let (key, role, seat) = asserted; + if !eligible(queue, item, policy, key, role, ledger, control)? { + return Ok(false); + } + let same_role = same(role, seat, ledger)?; + let mut found = false; + for row in &item.assignments { + super::decode_v2::checkpoint(ledger, control)?; + let key_match = same(&row.reviewer_key, key, ledger)?; + let role_match = same(&row.role_key, role, ledger)?; + found |= key_match && role_match && same_role; + } + for row in &policy.substitutions { + super::decode_v2::checkpoint(ledger, control)?; + let key_match = same(&row.reviewer_key, key, ledger)?; + let role_match = same(&row.asserted_role, role, ledger)?; + let seat_match = same(&row.seat_role, seat, ledger)?; + found |= key_match && role_match && seat_match; + } + Ok(found) +} +/// Bind a recorded witness's asserted key/role to the complete actual Queue policy. +fn witnesses( + queue: &QueueDocumentV4, + item: &ReviewItemV3, + policy: &ReviewPolicy, + document: &DispositionsDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let result = document.items.first().ok_or(ContractError::Binding)?; + let mut required = 0_u32; + for seat in &policy.seats { + super::decode_v2::checkpoint(ledger, control)?; + required = required.checked_add(seat.count).ok_or_else(|| ledger.capacity())?; + for ordinal in 0..seat.count { + ledger.visits(1)?; + let mut occurrences = 0_usize; + for met in &result.met_seats { + let role = same(&met.role_key, &seat.role_key, ledger)?; + ledger.bytes(8)?; + if role && met.ordinal == ordinal { + occurrences = occurrences.checked_add(1).ok_or_else(|| ledger.capacity())?; + } + } + for unmet in &result.unmet_seats { + let role = same(&unmet.role_key, &seat.role_key, ledger)?; + ledger.bytes(8)?; + if role && unmet.ordinal == ordinal { + occurrences = occurrences.checked_add(1).ok_or_else(|| ledger.capacity())?; + } + } + if occurrences != 1 { + return Err(ContractError::Binding); + } + } + } + ledger.bytes(16)?; + if required != result.required_seats + || required == 0 + || required > 100 + || result.met_seats.len().checked_add(result.unmet_seats.len()) != Some(required as usize) + { + return Err(ContractError::Binding); + } + for met in &result.met_seats { + let mut low = 0; + let mut high = document.responses.len(); + let mut found = None; + while low < high { + super::decode_v2::checkpoint(ledger, control)?; + let mid = low + (high - low) / 2; + let row = &document.responses[mid]; + strings(&[&row.response_id, &met.response_id], ledger)?; + match row.response_id.cmp(&met.response_id) { + std::cmp::Ordering::Less => low = mid + 1, + std::cmp::Ordering::Greater => high = mid, + std::cmp::Ordering::Equal => { + found = Some(row); + break; + } + } + } + let row = found.ok_or(ContractError::Binding)?; + strings( + &[ + &row.reviewer_key, + &met.reviewer_key, + &row.item_key, + &item.key, + &row.responded_at, + &queue.created_at, + &document.as_of, + item.due_at.as_deref().unwrap_or(""), + ], + ledger, + )?; + ledger.bytes(16)?; + if row.reviewer_key != met.reviewer_key + || row.item_key != item.key + || row.disposition != Disposition::Approve + || row.classification != super::wire_v4::ResponseClassification::Current + || row.responded_at < queue.created_at + || row.responded_at > document.as_of + || item.due_at.as_ref().is_some_and(|due| row.responded_at.as_str() >= due.as_str()) + || !seat_eligible( + queue, + item, + policy, + (&row.reviewer_key, &row.reviewer_role, &met.role_key), + ledger, + control, + )? + { + return Err(ContractError::Binding); + } + } + Ok(()) +} +/// Complete ordinary recorded-output/Queue correlation; loaded Current stays inert. +pub(crate) fn bind_dispositions( + queue: &DecodedV3<'_, QueueDocumentV4>, + recorded: &DecodedV3<'_, DispositionsDocumentV4>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let q = queue.document(); + let d = recorded.document(); + decode_v4::dispositions(d, ledger, control)?; + let item = q.items.first().ok_or(ContractError::Binding)?; + let result = d.items.first().ok_or(ContractError::Binding)?; + let policy = q.policies.first().ok_or(ContractError::Binding)?; + compared_pins(&q.source_pins, &d.source_pins, ledger)?; + strings( + &[ + &q.queue_id, + &d.queue_id, + queue.raw_sha256(), + &d.queue_raw_sha256, + &q.created_at, + &d.as_of, + &item.key, + &result.item_key, + &item.item_id, + &result.item_id, + ], + ledger, + )?; + if q.queue_id != d.queue_id + || queue.raw_sha256() != d.queue_raw_sha256 + || q.source_pins != d.source_pins + || d.as_of < q.created_at + || d.items.len() != 1 + || item.key != result.item_key + || item.item_id != result.item_id + { + return Err(ContractError::Binding); + } + witnesses(q, item, policy, d, ledger, control) + }) +} diff --git a/src/review/encode_v3.rs b/src/review/encode_v3.rs index 0ff30ab2..41191cc6 100644 --- a/src/review/encode_v3.rs +++ b/src/review/encode_v3.rs @@ -12,18 +12,21 @@ use crate::workspace::preparation::WorkControl; pub(crate) const MAX_QUEUE_BYTES: usize = 10_485_760; /// Admit a complete repeated string operand before serialization or equality. -fn text(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn text(value: &str, ledger: &mut ContractLedger) -> Result<(), ContractError> { ledger.visits(1)?; ledger.bytes(value.len()) } /// Admit bounded tags, list cardinalities and exact scalar comparisons. -fn fixed(count: usize, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn fixed(count: usize, ledger: &mut ContractLedger) -> Result<(), ContractError> { ledger.visits(count)?; let bytes = count.checked_mul(64).ok_or_else(|| ledger.capacity())?; ledger.bytes(bytes) } /// Preserve an explicit optional tag and full present value, including present-empty. -fn optional(value: Option<&str>, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn optional( + value: Option<&str>, + ledger: &mut ContractLedger, +) -> Result<(), ContractError> { fixed(1, ledger)?; if let Some(value) = value { text(value, ledger)?; @@ -31,7 +34,7 @@ fn optional(value: Option<&str>, ledger: &mut ContractLedger) -> Result<(), Cont Ok(()) } /// Admit every complete string in its actual order without sorting or omission. -fn strings(values: &[String], ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn strings(values: &[String], ledger: &mut ContractLedger) -> Result<(), ContractError> { fixed(1, ledger)?; for value in values { text(value, ledger)?; @@ -39,7 +42,7 @@ fn strings(values: &[String], ledger: &mut ContractLedger) -> Result<(), Contrac Ok(()) } /// Exhaustive eight-field pin operands; no native model/root/schema is discarded. -fn pin(value: &SourcePinV3, ledger: &mut ContractLedger) -> Result<(), ContractError> { +pub(crate) fn pin(value: &SourcePinV3, ledger: &mut ContractLedger) -> Result<(), ContractError> { let SourcePinV3 { artifact_key, kind: _, diff --git a/src/review/encode_v4.rs b/src/review/encode_v4.rs new file mode 100644 index 00000000..0386b036 --- /dev/null +++ b/src/review/encode_v4.rs @@ -0,0 +1,17 @@ +//! Finite separately closed edit-capable Response/4 and Dispositions/4 output/readback. +//! Queues remain the closed /3 shape and are encoded by the unchanged /3 encoder. +//! No encoded byte vector supplies native ownership or publication authority. + +/// Separately closed finite Response/4 and recorded Dispositions/4 output. +#[path = "encode_v4_operational.rs"] +mod operational; +#[cfg(test)] +pub(crate) use operational::readback_response; +pub(crate) use operational::{ + compare_dispositions, compare_responses, dispositions, dispositions_operands, response, + response_operands, +}; + +#[cfg(test)] +#[path = "encode_v4_tests.rs"] +mod tests; diff --git a/src/review/encode_v4_operational.rs b/src/review/encode_v4_operational.rs new file mode 100644 index 00000000..6068ed27 --- /dev/null +++ b/src/review/encode_v4_operational.rs @@ -0,0 +1,299 @@ +//! Finite separately closed plain Response/4 and Dispositions/4 output/readback. +use crate::review::decode::{ContractError, ContractLedger}; +use crate::review::decode_v2::{checkpoint, phase}; +use crate::review::encode_v3::{fixed, optional, pin, strings, text}; +use crate::review::wire_v4::{ + DispositionCounts, DispositionsDocumentV4, ItemDisposition, MetSeat, RecordedResponse, + ResponseDocumentV4, StateCounts, UnmetSeat, +}; +use crate::workspace::preparation::WorkControl; + +/// Every complete response field, including private evidence and required option tags. +pub(crate) fn response_operands( + value: &ResponseDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let ResponseDocumentV4 { + schema_version, + identity_disclaimer, + response_id, + queue_id, + queue_raw_sha256, + item_key, + item_id, + domain: _, + adapter_version, + requested_action: _, + source_pins, + subject_sha256, + context_sha256, + policy_sha256, + reviewer_key, + reviewer_role, + disposition: _, + responded_at, + rationale, + abstention_reason, + proposed_edit, + supersedes, + } = value; + fixed(5, ledger)?; + for value in [ + schema_version, + identity_disclaimer, + response_id, + queue_id, + queue_raw_sha256, + item_key, + item_id, + adapter_version, + subject_sha256, + context_sha256, + policy_sha256, + reviewer_key, + reviewer_role, + responded_at, + rationale, + ] { + text(value, ledger)?; + } + optional(abstention_reason.as_deref(), ledger)?; + fixed(1, ledger)?; + if let Some(edit) = proposed_edit { + text(&edit.target_subject_sha256, ledger)?; + text(&edit.patch, ledger)?; + text(&edit.patch_sha256, ledger)?; + fixed(1, ledger)?; + } + if let Some(value) = supersedes { + text(&value.response_id, ledger)?; + text(&value.raw_sha256, ledger)?; + } + fixed(1, ledger)?; + for value in source_pins { + checkpoint(ledger, control)?; + pin(value, ledger)?; + } + Ok(()) + }) +} +/// All minimized original response fields; no rationale is present in recorded data. +fn recorded_row( + value: &RecordedResponse, + ledger: &mut ContractLedger, +) -> Result<(), ContractError> { + let RecordedResponse { + response_id, + raw_sha256, + byte_length: _, + item_key, + reviewer_key, + reviewer_role, + disposition: _, + responded_at, + classification: _, + } = value; + fixed(3, ledger)?; + for value in [response_id, raw_sha256, item_key, reviewer_key, reviewer_role, responded_at] { + text(value, ledger)?; + } + Ok(()) +} +/// Every met-seat identity and ordinal, without performing matching or authenticating a key. +fn met(value: &MetSeat, ledger: &mut ContractLedger) -> Result<(), ContractError> { + let MetSeat { role_key, ordinal: _, reviewer_key, response_id } = value; + fixed(1, ledger)?; + for value in [role_key, reviewer_key, response_id] { + text(value, ledger)?; + } + Ok(()) +} +/// Preserve complete unmatched role/ordinal data as ordinary recorded evidence. +fn unmet(value: &UnmetSeat, ledger: &mut ContractLedger) -> Result<(), ContractError> { + let UnmetSeat { role_key, ordinal: _ } = value; + fixed(1, ledger)?; + text(role_key, ledger) +} +/// Complete item status, witness order, response roster and historical dissent operands. +fn item( + value: &ItemDisposition, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let ItemDisposition { + item_key, + item_id, + state: _, + reason_codes, + required_seats: _, + met_seats, + unmet_seats, + response_ids, + dissent_ids, + blocking: _, + } = value; + fixed(5, ledger)?; + text(item_key, ledger)?; + text(item_id, ledger)?; + strings(reason_codes, ledger)?; + strings(response_ids, ledger)?; + strings(dissent_ids, ledger)?; + fixed(2, ledger)?; + for value in met_seats { + checkpoint(ledger, control)?; + met(value, ledger)?; + } + for value in unmet_seats { + checkpoint(ledger, control)?; + unmet(value, ledger)?; + } + Ok(()) +} +/// Exhaustive four occurrence denominators and eight state counts. +fn counts(value: &DispositionCounts, ledger: &mut ContractLedger) -> Result<(), ContractError> { + let DispositionCounts { + items: _, + response_files: _, + unique_responses: _, + exact_duplicates: _, + states, + } = value; + let StateCounts { + unassigned: _, + assigned: _, + in_review: _, + conflicted: _, + changes_requested: _, + quorum_met: _, + expired: _, + stale: _, + } = states; + fixed(12, ledger) +} +/// All eleven recorded-document fields and every full nested operand before repeated work. +pub(crate) fn dispositions_operands( + value: &DispositionsDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let DispositionsDocumentV4 { + schema_version, + identity_disclaimer, + queue_id, + queue_raw_sha256, + as_of, + currentness: _, + closure_generation, + source_pins, + responses, + items, + counts: totals, + } = value; + fixed(7, ledger)?; + for value in [schema_version, identity_disclaimer, queue_id, queue_raw_sha256, as_of] { + text(value, ledger)?; + } + optional(closure_generation.as_deref(), ledger)?; + for value in source_pins { + checkpoint(ledger, control)?; + pin(value, ledger)?; + } + for value in responses { + checkpoint(ledger, control)?; + recorded_row(value, ledger)?; + } + for value in items { + checkpoint(ledger, control)?; + item(value, ledger, control)?; + } + counts(totals, ledger) + }) +} +/// Exhaustive semantic equality of both complete ordinary response declarations. +pub(crate) fn compare_responses( + expected: &ResponseDocumentV4, + actual: &ResponseDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + response_operands(expected, ledger, control)?; + response_operands(actual, ledger, control)?; + if expected != actual { + return Err(ContractError::Binding); + } + Ok(()) + }) +} +/// Exhaustive semantic equality of the whole ordinary recorded document and all witnesses. +pub(crate) fn compare_dispositions( + expected: &DispositionsDocumentV4, + actual: &DispositionsDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + dispositions_operands(expected, ledger, control)?; + dispositions_operands(actual, ledger, control)?; + if expected != actual { + return Err(ContractError::Binding); + } + Ok(()) + }) +} +/// Strict actual response bytes, including original whitespace/LF, precede complete Eq. +pub(crate) fn readback_response( + expected: &ResponseDocumentV4, + raw: &[u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let actual = crate::review::decode_v4::decode_response(raw, ledger, control)?; + compare_responses(expected, actual.document(), ledger, control) + }) +} +/// Strict complete recorded original bytes precede whole typed Eq, without a selected projection. +pub(crate) fn readback_dispositions( + expected: &DispositionsDocumentV4, + raw: &[u8], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + phase(ledger, control, |ledger, control| { + let actual = crate::review::decode_v4::decode_dispositions(raw, ledger, control)?; + compare_dispositions(expected, actual.document(), ledger, control) + }) +} +/// Finite compact immutable private response plus exactly one LF and actual-byte readback. +/// Output remains plain data; native binding/publication are separate actual owner duties. +pub(crate) fn response( + document: &ResponseDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + crate::review::decode_v4::response(document, ledger, control)?; + response_operands(document, ledger, control)?; + let raw = crate::review::encode_v2::admitted_json(document, 1_048_576, ledger, control)?; + readback_response(document, &raw, ledger, control)?; + Ok(raw) + }) +} +/// Finite complete recorded bundle plus LF; claimed currentness/quorum stays inert. +pub(crate) fn dispositions( + document: &DispositionsDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + phase(ledger, control, |ledger, control| { + crate::review::decode_v4::dispositions(document, ledger, control)?; + dispositions_operands(document, ledger, control)?; + let raw = crate::review::encode_v2::admitted_json(document, 33_554_432, ledger, control)?; + readback_dispositions(document, &raw, ledger, control)?; + Ok(raw) + }) +} diff --git a/src/review/encode_v4_tests.rs b/src/review/encode_v4_tests.rs new file mode 100644 index 00000000..59d210de --- /dev/null +++ b/src/review/encode_v4_tests.rs @@ -0,0 +1,132 @@ +//! Edit-capable /4 finite output and exact readback controls: a proposed edit survives +//! emit/readback/equality byte-exactly and never leaks into the public recorded bundle. +use super::{compare_responses, readback_response, response}; +use crate::hashing::sha256_hex; +use crate::review::decode::{ContractError, ContractLedger}; +use crate::review::wire_v3::NativeModelV3; +use crate::review::wire_v4::{ + ADAPTER, Disposition, DomainV3, IDENTITY_DISCLAIMER, PatchFormat, ProposedEdit, + RequestedAction, ResponseDocumentV4, SourceKindV3, SourcePinV3, +}; +use crate::workspace::preparation::NoopControl; + +/// Canonical plain review identity. +fn id(n: u8) -> String { + format!("{n:08x}-1111-4111-8111-111111111111") +} +/// One ordinary source pin; a digest is asserted data only. +fn pin(kind: SourceKindV3, key: &str, schema: Option<&str>, profile: &str) -> SourcePinV3 { + SourcePinV3 { + artifact_key: key.into(), + kind, + raw_sha256: "a".repeat(64), + byte_length: 17, + schema_identity: schema.map(str::to_owned), + validation_profile: profile.into(), + native_model: matches!(kind, SourceKindV3::Framework).then_some(NativeModelV3::Catalog), + native_root_uuid: matches!(kind, SourceKindV3::Framework) + .then(|| "AAAAAAAA-BBBB-4CCC-8DDD-EEEEEEEEEEEE".to_owned()), + } +} +/// The full ordinary six-purpose roster, sorted by artifact key. +fn pins() -> Vec { + let mut values = vec![ + pin( + SourceKindV3::AuthorProject, + "authoring:project", + Some("forge.author-project/1"), + "forge.author-project-intrinsic/1", + ), + pin( + SourceKindV3::AuthoringPack, + "authoring:pack", + Some("forge.authoring-pack/1"), + "forge.authoring-pack-intrinsic/1", + ), + pin( + SourceKindV3::GapReport, + "authoring:gap-report", + Some("forge.applicability-report/1"), + "forge.authoring-gap-report-complete/1", + ), + pin( + SourceKindV3::ApplicabilityManifest, + "authoring:applicability", + Some("forge.applicability/1"), + "forge.authoring-applicability-intrinsic/1", + ), + pin( + SourceKindV3::Framework, + "authoring:framework", + None, + "forge.authoring-framework-native/1", + ), + pin( + SourceKindV3::StoredPlan, + "authoring:plan", + Some("forge.authoring-plan/1"), + "forge.authoring-plan-complete-equality/1", + ), + ]; + values.sort_by(|a, b| a.artifact_key.cmp(&b.artifact_key)); + values +} +/// Complete private edit-capable response with a valid inert proposed edit. +fn document() -> ResponseDocumentV4 { + let patch = "# Replacement text\n"; + ResponseDocumentV4 { + schema_version: "forge.review-response/4".into(), + identity_disclaimer: IDENTITY_DISCLAIMER.into(), + response_id: id(1), + queue_id: id(9), + queue_raw_sha256: "a".repeat(64), + item_key: "whole-plan".into(), + item_id: id(8), + domain: DomainV3::AuthoringPlan, + adapter_version: ADAPTER.into(), + requested_action: RequestedAction::ReReview, + source_pins: pins(), + subject_sha256: "b".repeat(64), + context_sha256: "c".repeat(64), + policy_sha256: "d".repeat(64), + reviewer_key: "alice".into(), + reviewer_role: "approver".into(), + disposition: Disposition::Approve, + responded_at: "2026-10-01T00:00:00Z".into(), + rationale: "private reviewer evidence".into(), + abstention_reason: None, + proposed_edit: Some(ProposedEdit { + target_subject_sha256: "b".repeat(64), + patch_format: PatchFormat::FullText, + patch: patch.into(), + patch_sha256: sha256_hex(patch.as_bytes()), + }), + supersedes: None, + } +} + +/// Emit, strict readback and exhaustive typed equality retain the exact inert edit. +#[test] +fn emit_readback_equality_retains_edit() { + let document = document(); + let mut ledger = ContractLedger::default(); + let mut control = NoopControl; + let bytes = response(&document, &mut ledger, &mut control).expect("finite output"); + readback_response(&document, &bytes, &mut ledger, &mut control).expect("strict readback"); + let read = crate::review::decode_v4::decode_response(&bytes, &mut ledger, &mut control) + .expect("decode for field inspection"); + assert_eq!(read.document().proposed_edit.as_ref().unwrap().patch, "# Replacement text\n"); +} + +/// A changed patch byte breaks exhaustive equality; no silent reserialization is admitted. +#[test] +fn changed_patch_breaks_equality() { + let document = document(); + let mut ledger = ContractLedger::default(); + let mut control = NoopControl; + let mut changed: ResponseDocumentV4 = + serde_json::from_value(serde_json::to_value(&document).unwrap()).unwrap(); + changed.proposed_edit.as_mut().unwrap().patch = "# Different text\n".into(); + let result = compare_responses(&document, &changed, &mut ledger, &mut control); + assert!(matches!(result, Err(ContractError::Binding))); +} diff --git a/src/review/html.rs b/src/review/html.rs index 29136a92..5f9987fc 100644 --- a/src/review/html.rs +++ b/src/review/html.rs @@ -404,6 +404,7 @@ fn classification(value: ResponseClassification) -> &'static str { ResponseClassification::Unassigned => "unassigned", ResponseClassification::Superseded => "superseded", ResponseClassification::Conflicted => "conflicted", + ResponseClassification::InvalidEdit => "invalid-edit", } } diff --git a/src/review/lifecycle_response_tests.rs b/src/review/lifecycle_response_tests.rs index 49c616be..030e9495 100644 --- a/src/review/lifecycle_response_tests.rs +++ b/src/review/lifecycle_response_tests.rs @@ -35,7 +35,7 @@ fn options(fixture: &Fixture) -> RespondOptions<'_> { rationale_file: Path::new("rationale.txt"), item_key: "item-1", reviewer_key: "asserted-reviewer", reviewer_role: "review", disposition: Disposition::Approve, responded_at: "2026-10-05T00:00:01Z", response_id: "20000000-0000-4000-8000-000000000002", abstention_reason: None, - supersedes: None, output: Path::new("result.json") } + supersedes: None, proposed_patch: None, output: Path::new("result.json") } } /// Compare a precise safe contract cause without changing production error derives. diff --git a/src/review/merge.rs b/src/review/merge.rs index f4a4bc40..4a48d84a 100644 --- a/src/review/merge.rs +++ b/src/review/merge.rs @@ -420,7 +420,9 @@ fn evidence( ResponseClassification::Late => facts.late = Presence::Present, ResponseClassification::Unassigned => facts.unassigned = Presence::Present, ResponseClassification::Superseded => facts.superseded = Presence::Present, - ResponseClassification::Foreign => {} + // InvalidEdit is emitted only by the edit-capable /4 family; the + // zero-edit families treat it as inert non-approving evidence. + ResponseClassification::Foreign | ResponseClassification::InvalidEdit => {} } } Ok((facts, ids, dissent)) diff --git a/src/review/merge_v2.rs b/src/review/merge_v2.rs index 8a87db37..b94828a2 100644 --- a/src/review/merge_v2.rs +++ b/src/review/merge_v2.rs @@ -424,7 +424,9 @@ fn evidence( ResponseClassification::Late => facts.late = Presence::Present, ResponseClassification::Unassigned => facts.unassigned = Presence::Present, ResponseClassification::Superseded => facts.superseded = Presence::Present, - ResponseClassification::Foreign => {} + // InvalidEdit is emitted only by the edit-capable /4 family; the + // zero-edit families treat it as inert non-approving evidence. + ResponseClassification::Foreign | ResponseClassification::InvalidEdit => {} } } Ok((facts, ids, dissent)) diff --git a/src/review/merge_v3.rs b/src/review/merge_v3.rs index e568cc80..ecb8c620 100644 --- a/src/review/merge_v3.rs +++ b/src/review/merge_v3.rs @@ -425,7 +425,9 @@ fn evidence( ResponseClassification::Late => facts.late = Presence::Present, ResponseClassification::Unassigned => facts.unassigned = Presence::Present, ResponseClassification::Superseded => facts.superseded = Presence::Present, - ResponseClassification::Foreign => {} + // InvalidEdit is emitted only by the edit-capable /4 family; the + // zero-edit families treat it as inert non-approving evidence. + ResponseClassification::Foreign | ResponseClassification::InvalidEdit => {} } } Ok((facts, ids, dissent)) diff --git a/src/review/merge_v4.rs b/src/review/merge_v4.rs new file mode 100644 index 00000000..852c7ac7 --- /dev/null +++ b/src/review/merge_v4.rs @@ -0,0 +1,667 @@ +// A-authored separately typed /4 successor; old /1 and /2 source bodies are untouched. +//! Separate /4 typed-family successor; no /1 document or source-pin cast. +//! Pending declared-policy evaluation from exact borrowed queue/response originals. +//! This module does not serialize a disposition bundle or issue current quorum. +//! Native complete-currentness, physical capture and publication are separate +//! Root-owned ports. Asserted identities, role claims and times are unauthenticated. + +use super::chain::{compare, reserved}; +use super::chain_v3::visit; +use super::chain_v4::{self, ResponseRegistryV4}; +use super::decode::{ContractError, ContractLedger}; +use super::decode_v3::DecodedV3; +use super::quorum_v4; +use super::validate; +use super::wire::{ + Disposition, MetSeat, RecordedResponse, ResponseClassification, ReviewPolicy, UnmetSeat, +}; +use super::wire_v4::{QueueDocumentV4, ResponseDocumentV4, ReviewItemV3, SourcePinV3}; +use crate::workspace::preparation::WorkControl; + +/// Tentative asserted-policy outcome, deliberately not the public item state. +/// `SeatsFilled` cannot be displayed as current quorum until genuine closure binds. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum TentativeStateV4 { + /// No assigned/substitute participation is declared. + Unassigned, + /// Eligible assignments/substitutes exist but no counted participation. + Assigned, + /// Participation exists, including a blocking lone rejection. + InReview, + /// Divergent active asserted dispositions are preserved without a winner. + Conflicted, + /// Active request-changes blocks clean seat satisfaction. + ChangesRequested, + /// Maximum matching fills every seat, with no active blocker. + SeatsFilled, + /// Unsatisfied policy at or after the explicit due second. + Expired, + /// Only mismatching declared-binding evidence remains; no native stale claim. + BindingStale, +} + +/// Complete pending item facts, without any native transition or approval token. +pub(crate) struct ItemPolicyFactsV4 { + /// Selected original queue-local item key. + pub(crate) item_key: String, + /// Selected original deterministic item identity. + pub(crate) item_id: String, + /// Declared-policy outcome only. + pub(crate) tentative_state: TentativeStateV4, + /// All finite reason facts in lexical order, including currentness limitation. + pub(crate) reason_codes: Vec, + /// Complete positive declared approval denominator. + pub(crate) required_seats: u32, + /// Exact active approval witnesses, one asserted key per seat. + pub(crate) met_seats: Vec, + /// Complete remaining declared seats. + pub(crate) unmet_seats: Vec, + /// Every matching item-key response identity, including foreign/stale facts. + pub(crate) response_ids: Vec, + /// Every reject/request-changes identity, including withdrawn/history facts. + pub(crate) dissent_ids: Vec, + /// Active rejection, changes request or divergent disposition remains blocking. + pub(crate) blocking: bool, +} + +/// Complete counts in the pending original cohort; no deduplicated file fiction. +pub(crate) struct PendingCountsV4 { + /// Number of selected queue items. + pub(crate) items: usize, + /// Every actual bounded response original, including exact duplicate holders. + pub(crate) response_files: usize, + /// Distinct explicit UUID/raw identities. + pub(crate) unique_responses: usize, + /// Additional byte-identical UUID originals. + pub(crate) exact_duplicates: usize, +} + +/// Opaque pending owner. No Serialize, Clone, Debug, detached constructor, +/// success seal or conversion into a current disposition bundle is provided. +pub(crate) struct PendingPolicyEvaluationV4<'a> { + /// Actual decoded queue and complete original-byte lifetime. + queue: &'a DecodedV3<'a, QueueDocumentV4>, + /// Every actual original response holder and validated chain. + registry: ResponseRegistryV4<'a>, + /// Explicit canonical evaluation time; never an ambient machine clock. + as_of: String, + /// All unique minimized response facts, with complete raw pins. + responses: Vec, + /// All selected pending item facts, with dissent and full seats. + items: Vec, + /// Full file/identity denominators. + counts: PendingCountsV4, +} + +impl<'a> PendingPolicyEvaluationV4<'a> { + /// Borrow the exact queue owner required by a future genuine currentness gate. + pub(crate) fn queue(&self) -> &'a DecodedV3<'a, QueueDocumentV4> { + self.queue + } + /// Borrow every actual original, including additional exact duplicate files. + pub(crate) fn originals(&self) -> &'a [DecodedV3<'a, ResponseDocumentV4>] { + self.registry.originals() + } + /// Borrow the explicit declared evaluation second. + pub(crate) fn as_of(&self) -> &str { + &self.as_of + } + /// Borrow pending minimized evidence; it grants no currentness or authority. + pub(crate) fn responses(&self) -> &[RecordedResponse] { + &self.responses + } + /// Borrow tentative policy outcomes, never public current quorum states. + pub(crate) fn items(&self) -> &[ItemPolicyFactsV4] { + &self.items + } + /// Borrow complete original denominators. + pub(crate) fn counts(&self) -> &PendingCountsV4 { + &self.counts + } +} + +/// Copy only an admitted minimized extent, with work/storage charged before growth. +fn text(value: &str, ledger: &mut ContractLedger) -> Result { + ledger.bytes(value.len())?; + ledger.derived(value.len())?; + let mut result = String::new(); + result.try_reserve_exact(value.len()).map_err(|_| ContractError::Capacity)?; + result.push_str(value); + Ok(result) +} + +/// Precharge both complete typed source-pin extents before equality comparisons. +fn pin_work( + pins: &[SourcePinV3], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + for pin in pins { + visit(ledger, control)?; + let mut extent = 64_usize; + for size in [ + pin.artifact_key.len(), + pin.schema_identity.as_ref().map_or(0, String::len), + pin.validation_profile.len(), + pin.raw_sha256.len(), + pin.native_root_uuid.as_ref().map_or(0, String::len), + ] { + extent = extent.checked_add(size).ok_or(ContractError::Capacity)?; + } + ledger.bytes(extent)?; + } + Ok(()) +} + +/// Inspect all declared-binding fields before deciding stale versus eligibility. +fn snapshot_matches( + queue: &DecodedV3<'_, QueueDocumentV4>, + item: &ReviewItemV3, + response: &ResponseDocumentV4, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + pin_work(&queue.document().source_pins, ledger, control)?; + pin_work(&response.source_pins, ledger, control)?; + let pairs = [ + (&response.queue_raw_sha256[..], queue.raw_sha256()), + (&response.item_id, &item.item_id), + (&response.adapter_version, &item.adapter_version), + (&response.subject_sha256, &item.subject_sha256), + (&response.context_sha256, &item.context_sha256), + (&response.policy_sha256, &item.policy_sha256), + ]; + let mut equal = true; + for (left, right) in pairs { + visit(ledger, control)?; + equal &= compare(left, right, ledger)?.is_eq(); + } + ledger.bytes(16)?; + Ok(equal + && response.domain == item.domain + && response.requested_action == item.requested_action + && response.source_pins == queue.document().source_pins) +} + +/// Exact item lookup in the structurally admitted sorted roster, without cloning. +fn selected<'a>( + queue: &'a QueueDocumentV4, + key: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut low = 0; + let mut high = queue.items.len(); + while low < high { + visit(ledger, control)?; + let middle = low + (high - low) / 2; + match compare(&queue.items[middle].key, key, ledger)? { + std::cmp::Ordering::Less => low = middle + 1, + std::cmp::Ordering::Greater => high = middle, + std::cmp::Ordering::Equal => return Ok(Some(&queue.items[middle])), + } + } + Ok(None) +} + +/// Scan every declared reviewer with checkpoints and both key extents charged. +/// Unknown asserted keys remain nonapproving evidence; structural binding errors +/// still propagate through the unchanged response validator. +fn reviewer_is_declared( + queue: &QueueDocumentV4, + key: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + let mut declared = false; + for reviewer in &queue.reviewers { + visit(ledger, control)?; + declared |= compare(&reviewer.key, key, ledger)?.is_eq(); + } + Ok(declared) +} + +/// Classify declared binding/eligibility/time; no native freshness is inferred. +fn classify( + queue: &DecodedV3<'_, QueueDocumentV4>, + response: &DecodedV3<'_, ResponseDocumentV4>, + as_of: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + visit(ledger, control)?; + let document = response.document(); + if !compare(&document.queue_id, &queue.document().queue_id, ledger)?.is_eq() { + return Ok(ResponseClassification::Foreign); + } + let Some(item) = selected(queue.document(), &document.item_key, ledger, control)? else { + return Ok(ResponseClassification::Foreign); + }; + if !snapshot_matches(queue, item, document, ledger, control)? + || compare(&document.responded_at, &queue.document().created_at, ledger)?.is_lt() + { + return Ok(ResponseClassification::Stale); + } + if !reviewer_is_declared(queue.document(), &document.reviewer_key, ledger, control)? { + return Ok(ResponseClassification::Unassigned); + } + match super::edit_response_binding::bind_response(queue, response, ledger, control) { + Ok(()) => {} + Err(ContractError::Binding) => return Ok(ResponseClassification::Unassigned), + Err(error) => return Err(error), + } + if let Some(edit) = &document.proposed_edit { + // AC-5: a patch bound to a different subject targets stale evidence; a + // malformed envelope is invalid-edit. Both classify this response only; + // the merge continues and the patch is never applied (M-10, G-4). + if !compare(&edit.target_subject_sha256, &item.subject_sha256, ledger)?.is_eq() { + return Ok(ResponseClassification::Stale); + } + if !super::edit_response_binding::edit_well_formed( + edit, + &item.subject_sha256, + ledger, + control, + )? { + return Ok(ResponseClassification::InvalidEdit); + } + } + if compare(&document.responded_at, as_of, ledger)?.is_gt() { + return Ok(ResponseClassification::Future); + } + if let Some(due) = &item.due_at + && !compare(&document.responded_at, due, ledger)?.is_lt() + { + return Ok(ResponseClassification::Late); + } + Ok(ResponseClassification::Current) +} + +/// Retire only exact eligible timely withdrawals. Withdrawal-of-withdrawal never +/// reopens a prior vote, and future/late markers cannot erase a timely approval. +fn retire( + registry: &ResponseRegistryV4<'_>, + classes: &mut [ResponseClassification], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let mut targets = reserved(registry.len(), ledger)?; + for (index, &class) in classes.iter().enumerate().take(registry.len()) { + visit(ledger, control)?; + if class == ResponseClassification::Current + && let Some(target) = registry.target(index) + { + targets.push(target); + } + } + for target in targets { + visit(ledger, control)?; + if classes[target] == ResponseClassification::Current { + classes[target] = ResponseClassification::Superseded; + } + } + for (index, class) in classes.iter_mut().enumerate() { + visit(ledger, control)?; + if *class == ResponseClassification::Current + && registry.get(index).document().disposition == Disposition::Superseded + { + *class = ResponseClassification::Superseded; + } + } + Ok(()) +} + +/// Fixed disposition bit for detecting divergence without choosing a winner. +fn vote_bit(disposition: Disposition) -> u8 { + match disposition { + Disposition::Approve => 1, + Disposition::Reject => 2, + Disposition::RequestChanges => 4, + Disposition::Abstain => 8, + Disposition::Superseded => 0, + } +} + +/// Preserve every divergent active assertion and exclude conflicted keys from seats. +fn mark_conflicts( + queue: &QueueDocumentV4, + registry: &ResponseRegistryV4<'_>, + classes: &mut [ResponseClassification], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + for item in &queue.items { + for reviewer in &queue.reviewers { + visit(ledger, control)?; + let mut mask = 0_u8; + for (index, &class) in classes.iter().enumerate() { + visit(ledger, control)?; + let response = registry.get(index).document(); + if class == ResponseClassification::Current + && compare(&response.item_key, &item.key, ledger)?.is_eq() + && compare(&response.reviewer_key, &reviewer.key, ledger)?.is_eq() + { + mask |= vote_bit(response.disposition); + } + } + if mask.count_ones() > 1 { + for (index, class) in classes.iter_mut().enumerate() { + visit(ledger, control)?; + let response = registry.get(index).document(); + if *class == ResponseClassification::Current + && compare(&response.item_key, &item.key, ledger)?.is_eq() + && compare(&response.reviewer_key, &reviewer.key, ledger)?.is_eq() + { + *class = ResponseClassification::Conflicted; + } + } + } + } + } + Ok(()) +} + +/// Presence of one independent response fact; other facts may coexist. +#[derive(Clone, Copy, Default)] +enum Presence { + /// No inspected response has contributed this fact. + #[default] + Absent, + /// At least one inspected response has contributed this fact. + Present, +} + +impl Presence { + /// Preserve an earlier occurrence while including one new independent fact. + fn include(&mut self, present: bool) { + if present { + *self = Self::Present; + } + } + + /// Read this fact without excluding any other recorded fact. + fn is_present(self) -> bool { + matches!(self, Self::Present) + } +} + +/// Complete finite response facts used for pending state priority and reasons. +/// Each presence field is independent; no mutually exclusive state replaces it. +#[derive(Default)] +struct Evidence { + /// At least one active eligible disposition, including abstention/conflict. + active: Presence, + /// Complete decisive active disposition bit union across asserted keys. + decisive: u8, + /// At least one same-key divergent assertion. + key_conflict: Presence, + /// Stale declared-binding evidence exists, not a native stale assertion. + stale: Presence, + /// At least one asserted response after as-of. + future: Presence, + /// At least one ineligible due-boundary/after-due response. + late: Presence, + /// At least one nonapproving active abstention. + abstain: Presence, + /// Unassigned/asserted-author/incompatible role evidence exists. + unassigned: Presence, + /// Withdrawn history or a timely withdrawal marker remains visible. + superseded: Presence, +} + +/// Inspect every item-key response and preserve complete dissent references. +fn evidence( + item: &ReviewItemV3, + registry: &ResponseRegistryV4<'_>, + classes: &[ResponseClassification], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(Evidence, Vec, Vec), ContractError> { + let mut facts = Evidence::default(); + let mut ids = reserved(registry.len(), ledger)?; + let mut dissent = reserved(registry.len(), ledger)?; + for (index, &class) in classes.iter().enumerate() { + visit(ledger, control)?; + let response = registry.get(index).document(); + if !compare(&response.item_key, &item.key, ledger)?.is_eq() { + continue; + } + ids.push(text(&response.response_id, ledger)?); + if matches!(response.disposition, Disposition::Reject | Disposition::RequestChanges) { + dissent.push(text(&response.response_id, ledger)?); + } + match class { + ResponseClassification::Current | ResponseClassification::Conflicted => { + facts.active = Presence::Present; + facts.decisive |= vote_bit(response.disposition) & 7; + facts.key_conflict.include(class == ResponseClassification::Conflicted); + facts.abstain.include(response.disposition == Disposition::Abstain); + } + ResponseClassification::Stale => facts.stale = Presence::Present, + ResponseClassification::Future => facts.future = Presence::Present, + ResponseClassification::Late => facts.late = Presence::Present, + ResponseClassification::Unassigned => facts.unassigned = Presence::Present, + ResponseClassification::Superseded => facts.superseded = Presence::Present, + // InvalidEdit is emitted only by the edit-capable /4 family; the + // zero-edit families treat it as inert non-approving evidence. + ResponseClassification::Foreign | ResponseClassification::InvalidEdit => {} + } + } + Ok((facts, ids, dissent)) +} + +/// Preserve explicit state priority while keeping unverified seats distinctly named. +fn state( + item: &ReviewItemV3, + policy: &ReviewPolicy, + facts: &Evidence, + complete: bool, + as_of: &str, + ledger: &mut ContractLedger, +) -> Result { + if facts.stale.is_present() && !facts.active.is_present() { + return Ok(TentativeStateV4::BindingStale); + } + if facts.key_conflict.is_present() || facts.decisive.count_ones() > 1 { + return Ok(TentativeStateV4::Conflicted); + } + if facts.decisive & 4 != 0 { + return Ok(TentativeStateV4::ChangesRequested); + } + if complete && facts.decisive & 2 == 0 { + return Ok(TentativeStateV4::SeatsFilled); + } + if let Some(due) = &item.due_at + && !compare(as_of, due, ledger)?.is_lt() + { + return Ok(TentativeStateV4::Expired); + } + if facts.active.is_present() { + return Ok(TentativeStateV4::InReview); + } + if !item.assignments.is_empty() || !policy.substitutions.is_empty() { + return Ok(TentativeStateV4::Assigned); + } + Ok(TentativeStateV4::Unassigned) +} + +/// All applicable reason tokens in fixed lexical order; no input prose is exposed. +fn reasons( + facts: &Evidence, + state: TentativeStateV4, + ledger: &mut ContractLedger, +) -> Result, ContractError> { + let mut result = reserved(13, ledger)?; + let flags = [ + (state == TentativeStateV4::SeatsFilled, "approval-seats-filled"), + (true, "asserted-identity-only"), + (facts.stale.is_present(), "binding-stale"), + ( + facts.key_conflict.is_present() || facts.decisive.count_ones() > 1, + "conflicting-dispositions", + ), + (true, "currentness-unverified"), + (state == TentativeStateV4::Expired, "deadline-unsatisfied"), + (facts.future.is_present(), "future-responses"), + (facts.late.is_present(), "late-responses"), + (facts.abstain.is_present(), "nonapproving-abstention"), + (facts.decisive & 2 != 0, "rejection-blocks"), + (facts.decisive & 4 != 0, "request-changes-blocks"), + (facts.unassigned.is_present(), "unassigned-responses"), + (facts.superseded.is_present(), "withdrawn-history"), + ]; + for (present, token) in flags { + ledger.visits(1)?; + if present { + result.push(text(token, ledger)?); + } + } + Ok(result) +} + +/// Resolve the actual declared policy through a charged finite scan. +fn policy<'a>( + queue: &'a QueueDocumentV4, + item: &ReviewItemV3, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<&'a ReviewPolicy, ContractError> { + for policy in &queue.policies { + visit(ledger, control)?; + if compare(&policy.key, &item.policy_key, ledger)?.is_eq() { + return Ok(policy); + } + } + Err(ContractError::Invalid) +} + +/// One complete pending item, with precharged owned projection and full witnesses. +fn item_facts( + queue: &QueueDocumentV4, + item: &ReviewItemV3, + registry: &ResponseRegistryV4<'_>, + classes: &[ResponseClassification], + as_of: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + let policy = policy(queue, item, ledger, control)?; + let (facts, response_ids, dissent_ids) = evidence(item, registry, classes, ledger, control)?; + let matched = quorum_v4::evaluate(queue, item, policy, registry, classes, ledger, control)?; + let mut met = reserved(matched.seats.len(), ledger)?; + let mut unmet = reserved(matched.seats.len(), ledger)?; + for (seat, witness) in matched.seats.iter().zip(&matched.witnesses) { + visit(ledger, control)?; + match witness { + Some(index) => { + let response = registry.get(*index).document(); + met.push(MetSeat { + role_key: text(seat.role, ledger)?, + ordinal: seat.ordinal, + reviewer_key: text(&response.reviewer_key, ledger)?, + response_id: text(&response.response_id, ledger)?, + }); + } + None => { + unmet.push(UnmetSeat { role_key: text(seat.role, ledger)?, ordinal: seat.ordinal }); + } + } + } + let tentative = state(item, policy, &facts, unmet.is_empty(), as_of, ledger)?; + Ok(ItemPolicyFactsV4 { + item_key: text(&item.key, ledger)?, + item_id: text(&item.item_id, ledger)?, + tentative_state: tentative, + reason_codes: reasons(&facts, tentative, ledger)?, + required_seats: u32::try_from(matched.seats.len()).map_err(|_| ContractError::Capacity)?, + met_seats: met, + unmet_seats: unmet, + response_ids, + dissent_ids, + blocking: facts.key_conflict.is_present() + || facts.decisive.count_ones() > 1 + || facts.decisive & 6 != 0, + }) +} + +/// Minimize an actual original without replacing its raw holder or rationale. +fn recorded( + response: &DecodedV3<'_, ResponseDocumentV4>, + classification: ResponseClassification, + ledger: &mut ContractLedger, +) -> Result { + let document = response.document(); + Ok(RecordedResponse { + response_id: text(&document.response_id, ledger)?, + raw_sha256: text(response.raw_sha256(), ledger)?, + byte_length: u64::try_from(response.raw().len()).map_err(|_| ContractError::Capacity)?, + item_key: text(&document.item_key, ledger)?, + reviewer_key: text(&document.reviewer_key, ledger)?, + reviewer_role: text(&document.reviewer_role, ledger)?, + disposition: document.disposition, + responded_at: text(&document.responded_at, ledger)?, + classification, + }) +} + +/// Prepare complete in-memory chain and asserted-policy facts atomically. +/// All raw inputs must have been decoded with this same command ledger; caller +/// IO owns complete attempt/physical-alias counts. Native currentness is absent. +pub(crate) fn prepare_policy<'a>( + queue: &'a DecodedV3<'a, QueueDocumentV4>, + responses: &'a [DecodedV3<'a, ResponseDocumentV4>], + as_of: &str, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + super::decode_v2::phase(ledger, control, |ledger, control| { + ledger.checkpoint(control)?; + ledger.bytes(as_of.len())?; + ledger.derived(84)?; + validate::time(as_of)?; + if compare(as_of, &queue.document().created_at, ledger)?.is_lt() { + return Err(ContractError::Invalid); + } + let registry = chain_v4::prepare(responses, ledger, control)?; + let mut classes = reserved(registry.len(), ledger)?; + for index in 0..registry.len() { + classes.push(classify(queue, registry.get(index), as_of, ledger, control)?); + } + retire(®istry, &mut classes, ledger, control)?; + mark_conflicts(queue.document(), ®istry, &mut classes, ledger, control)?; + let mut items = reserved(queue.document().items.len(), ledger)?; + for item in &queue.document().items { + visit(ledger, control)?; + items.push(item_facts( + queue.document(), + item, + ®istry, + &classes, + as_of, + ledger, + control, + )?); + } + let mut projected = reserved(registry.len(), ledger)?; + for (index, class) in classes.into_iter().enumerate() { + visit(ledger, control)?; + projected.push(recorded(registry.get(index), class, ledger)?); + } + let counts = PendingCountsV4 { + items: items.len(), + response_files: responses.len(), + unique_responses: registry.len(), + exact_duplicates: registry.duplicates(), + }; + let as_of = text(as_of, ledger)?; + ledger.checkpoint(control)?; + Ok(PendingPolicyEvaluationV4 { + queue, + registry, + as_of, + responses: projected, + items, + counts, + }) + }) +} diff --git a/src/review/mod.rs b/src/review/mod.rs index 38c62466..8bc58644 100644 --- a/src/review/mod.rs +++ b/src/review/mod.rs @@ -144,3 +144,26 @@ pub(crate) mod authoring_queue_export; /// Whole native Authoring review command lifetime through actual output sinks. pub(crate) mod authoring_commands; + +/// Complete plain /4 original identity and withdrawal chain, without native authority. +pub(crate) mod chain_v4; +/// Strict plain edit-capable Response/4 and Dispositions/4 codec; no native owner. +#[path = "decode_v4.rs"] +pub(crate) mod decode_v4; +/// Genuine Authoring Queue and every actual /4 Response original over one native owner. +pub(crate) mod edit_binding; +/// Whole native edit-capable review command lifetime through actual output sinks. +pub(crate) mod edit_commands; +/// Actual private edit-capable current-output issuer over a genuine complete binding. +pub(crate) mod edit_finalize; +/// Ordinary separately typed /4 Response/recorded-output assertion binding and edit syntax. +pub(crate) mod edit_response_binding; +/// Finite plain edit-capable Response/4 and Dispositions/4 serializer with readback. +#[path = "encode_v4.rs"] +pub(crate) mod encode_v4; +/// Pending /4 classification (incl. per-response edit validation) and policy facts. +pub(crate) mod merge_v4; +/// Independently typed asserted /4 distinct-key maximum matching. +pub(crate) mod quorum_v4; +/// Separately closed inert edit-capable /4 response declarations; queues stay /3. +pub(crate) mod wire_v4; diff --git a/src/review/quorum_v4.rs b/src/review/quorum_v4.rs new file mode 100644 index 00000000..97bce983 --- /dev/null +++ b/src/review/quorum_v4.rs @@ -0,0 +1,272 @@ +// A-authored separately typed /4 successor; old /1 and /2 source bodies are untouched. +//! Separate /4 typed-family successor; no /1 document or source-pin cast. +//! Deterministic maximum matching of declared approval keys to finite seats. +//! Matching never authenticates keys, removes dissent or proves native currency. + +use super::chain::{compare, reserved}; +use super::chain_v3::visit; +use super::chain_v4::ResponseRegistryV4; +use super::decode::{ContractError, ContractLedger}; +use super::wire::{Disposition, ResponseClassification, ReviewPolicy}; +use super::wire_v4::{QueueDocumentV4, ReviewItemV3}; +use crate::workspace::preparation::WorkControl; + +/// One expanded positive declared approval seat, borrowing its original role. +pub(super) struct Seat<'a> { + /// Exact declared role, without normalization. + pub(super) role: &'a str, + /// Original zero-based ordinal within that role's positive requirement. + pub(super) ordinal: u32, +} + +/// Private complete matching facts; one key owns at most one seat. +pub(super) struct Matching<'a> { + /// Every declared seat, in role/ordinal order. + pub(super) seats: Vec>, + /// Original unique response index per met seat; none preserves unmet seats. + pub(super) witnesses: Vec>, +} + +/// Every repeated node, edge and backtrack obeys the same control and ledger. +fn step(ledger: &mut ContractLedger, control: &mut dyn WorkControl) -> Result<(), ContractError> { + super::decode_v2::checkpoint(ledger, control)?; + ledger.matching(1) +} + +/// Materialize complete finite seats only after checked count admission. +fn seats<'a>( + policy: &'a ReviewPolicy, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result>, ContractError> { + let mut count = 0_usize; + for required in &policy.seats { + visit(ledger, control)?; + count = count + .checked_add(usize::try_from(required.count).map_err(|_| ContractError::Capacity)?) + .ok_or(ContractError::Capacity)?; + } + if count == 0 || count > 100 { + return Err(ContractError::Capacity); + } + let mut result = reserved(count, ledger)?; + for required in &policy.seats { + for ordinal in 0..required.count { + step(ledger, control)?; + result.push(Seat { role: &required.role_key, ordinal }); + } + } + Ok(result) +} + +/// Charge complete original comparison extents before inspecting a declared edge. +fn eligible( + item: &ReviewItemV3, + policy: &ReviewPolicy, + response: &super::wire_v4::ResponseDocumentV4, + seat: &Seat<'_>, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result { + let same_role = compare(&response.reviewer_role, seat.role, ledger)?.is_eq(); + for assigned in &item.assignments { + step(ledger, control)?; + if compare(&assigned.reviewer_key, &response.reviewer_key, ledger)?.is_eq() + && compare(&assigned.role_key, &response.reviewer_role, ledger)?.is_eq() + && same_role + { + return Ok(true); + } + } + for edge in &policy.substitutions { + step(ledger, control)?; + if compare(&edge.reviewer_key, &response.reviewer_key, ledger)?.is_eq() + && compare(&edge.asserted_role, &response.reviewer_role, ledger)?.is_eq() + && compare(&edge.seat_role, seat.role, ledger)?.is_eq() + { + return Ok(true); + } + } + Ok(false) +} + +/// Preserve roster order and select only keys with a live nonconflicted approval. +fn candidates( + queue: &QueueDocumentV4, + item: &ReviewItemV3, + registry: &ResponseRegistryV4<'_>, + classifications: &[ResponseClassification], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut keys = reserved(queue.reviewers.len(), ledger)?; + for (key_index, key) in queue.reviewers.iter().enumerate() { + visit(ledger, control)?; + let mut approving = false; + for (index, &classification) in classifications.iter().enumerate() { + visit(ledger, control)?; + let response = registry.get(index).document(); + if classification == ResponseClassification::Current + && response.disposition == Disposition::Approve + && compare(&response.item_key, &item.key, ledger)?.is_eq() + && compare(&response.reviewer_key, &key.key, ledger)?.is_eq() + { + approving = true; + } + } + if approving { + keys.push(key_index); + } + } + Ok(keys) +} + +/// Build a checked dense matrix of exact approval witnesses, never fake edges. +fn edges( + selection: (&QueueDocumentV4, &ReviewItemV3, &ReviewPolicy), + registry: &ResponseRegistryV4<'_>, + classes: &[ResponseClassification], + seats: &[Seat<'_>], + keys: &[usize], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result>, ContractError> { + let (queue, item, policy) = selection; + let count = keys.len().checked_mul(seats.len()).ok_or(ContractError::Capacity)?; + if count > 10_000 { + return Err(ContractError::Capacity); + } + let mut result = reserved(count, ledger)?; + for &key in keys { + for seat in seats { + let mut witness = None; + for (index, &class) in classes.iter().enumerate() { + step(ledger, control)?; + let response = registry.get(index).document(); + if class == ResponseClassification::Current + && response.disposition == Disposition::Approve + && compare(&response.item_key, &item.key, ledger)?.is_eq() + && compare(&response.reviewer_key, &queue.reviewers[key].key, ledger)?.is_eq() + && eligible(item, policy, response, seat, ledger, control)? + { + witness = Some(index); + break; + } + } + result.push(witness); + } + } + Ok(result) +} + +/// Reset and reserve bounded search state once; all repeated resets are charged. +fn reset( + count: usize, + value: T, + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + let mut result = reserved(count, ledger)?; + for _ in 0..count { + step(ledger, control)?; + result.push(value); + } + Ok(result) +} + +/// One iterative breadth-first augmenting path, with no recursive matching. +fn augment( + root: usize, + width: usize, + edges: &[Option], + key_match: &mut [Option], + seat_match: &mut [Option], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let mut seen_keys = reset(key_match.len(), false, ledger, control)?; + let mut parents = reset(width, None, ledger, control)?; + let mut queue = reserved(key_match.len(), ledger)?; + seen_keys[root] = true; + queue.push(root); + let mut head = 0; + while head < queue.len() { + step(ledger, control)?; + let key = queue[head]; + head += 1; + for seat in 0..width { + step(ledger, control)?; + if edges[key * width + seat].is_none() || parents[seat].is_some() { + continue; + } + parents[seat] = Some(key); + match seat_match[seat] { + None => return flip(seat, &parents, key_match, seat_match, ledger, control), + Some(owner) if !seen_keys[owner] => { + seen_keys[owner] = true; + queue.push(owner); + } + Some(_) => {} + } + } + } + Ok(()) +} + +/// Replace the full augmenting path; no key gains a second occupied seat. +fn flip( + free: usize, + parents: &[Option], + key_match: &mut [Option], + seat_match: &mut [Option], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result<(), ContractError> { + let mut cursor = Some(free); + while let Some(seat) = cursor { + step(ledger, control)?; + let key = parents[seat].ok_or(ContractError::Invalid)?; + let previous = key_match[key]; + key_match[key] = Some(seat); + seat_match[seat] = Some(key); + cursor = previous; + } + Ok(()) +} + +/// Compute maximum seat cardinality; conflicts are removed by the caller first. +pub(super) fn evaluate<'a>( + queue: &'a QueueDocumentV4, + item: &'a ReviewItemV3, + policy: &'a ReviewPolicy, + registry: &ResponseRegistryV4<'_>, + classifications: &[ResponseClassification], + ledger: &mut ContractLedger, + control: &mut dyn WorkControl, +) -> Result, ContractError> { + super::decode_v2::phase(ledger, control, |ledger, control| { + let seats = seats(policy, ledger, control)?; + let keys = candidates(queue, item, registry, classifications, ledger, control)?; + let edges = edges( + (queue, item, policy), + registry, + classifications, + &seats, + &keys, + ledger, + control, + )?; + let mut key_match = reset(keys.len(), None, ledger, control)?; + let mut seat_match = reset(seats.len(), None, ledger, control)?; + for key in 0..keys.len() { + step(ledger, control)?; + augment(key, seats.len(), &edges, &mut key_match, &mut seat_match, ledger, control)?; + } + let mut witnesses = reserved(seats.len(), ledger)?; + for (seat, owner) in seat_match.into_iter().enumerate() { + step(ledger, control)?; + witnesses.push(owner.and_then(|key| edges[key * seats.len() + seat])); + } + Ok(Matching { seats, witnesses }) + }) +} diff --git a/src/review/wire.rs b/src/review/wire.rs index 9f072246..0f7b4390 100644 --- a/src/review/wire.rs +++ b/src/review/wire.rs @@ -110,6 +110,8 @@ pub(crate) enum ResponseClassification { Superseded, /// Exact `conflicted` wire value. Conflicted, + /// Exact `invalid-edit` wire value; only the edit-capable /4 family emits it. + InvalidEdit, } /// PRD presentation states; quorum-met is review policy only. diff --git a/src/review/wire_v4.rs b/src/review/wire_v4.rs new file mode 100644 index 00000000..29d7cc98 --- /dev/null +++ b/src/review/wire_v4.rs @@ -0,0 +1,105 @@ +//! Separately closed edit-capable Authoring exchange declarations (family /4). +//! Mirrors the /3 typed stack; the queue/item/pin shapes are identical and reused. +//! The only envelope change is `proposed_edit: Option` on responses. +//! Proposed edits are inert unapproved patches: merge validates syntax and target +//! hash per response and NEVER applies them (PRD 068 M-10, G-4). No declaration, +//! digest or loaded currentness label supplies a native owner. + +use serde::{Deserialize, Serialize}; + +pub(crate) use super::wire::{ + Disposition, DispositionCounts, IDENTITY_DISCLAIMER, ItemDisposition, ItemState, MetSeat, + RecordedCurrentness, RecordedResponse, RequestedAction, ResponseClassification, ReviewPolicy, + StateCounts, SupersessionReference, UnmetSeat, +}; +pub(crate) use super::wire_v3::{DomainV3, ReviewItemV3, SourceKindV3, SourcePinV3}; + +/// Queue and recorded-bundle shapes are byte-identical to /3; only the version +/// tokens differ, so the closed /3 declarations are reused without a second shape. +pub(crate) use super::wire_v3::{ + DispositionsDocumentV3 as DispositionsDocumentV4, QueueDocumentV3 as QueueDocumentV4, +}; +/// Fixed identity-only Authoring-plan adapter revision, shared with family /3. +pub(crate) const ADAPTER: &str = "forge.authoring-plan-review/1"; +/// Exact closed edit-capable response version. +pub(crate) const RESPONSE_VERSION: &str = "forge.review-response/4"; + +/// Complete proposed replacement UTF-8 text for one bound subject original. +/// The subject is one whole Markdown document (plan or clause); the single closed +/// format proposes its full replacement text. Syntax validation is total: bounded +/// nonempty UTF-8 plus exact digest integrity. The patch is never applied by review. +#[derive(Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "kebab-case")] +pub(crate) enum PatchFormat { + /// Complete replacement text for the target subject original. + FullText, +} + +/// Closed inert proposed-edit envelope; unapproved patch data, never an application. +#[derive(Serialize, Deserialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub(crate) struct ProposedEdit { + /// Exact subject original the patch targets; bound against item and response. + pub(crate) target_subject_sha256: String, + /// Single closed patch format. + pub(crate) patch_format: PatchFormat, + /// Bounded complete replacement UTF-8 text, at most 64 KiB. + pub(crate) patch: String, + /// Exact SHA-256 of the patch UTF-8 bytes. + pub(crate) patch_sha256: String, +} + +/// Private immutable edit-capable response declarations; rationale is never public. +/// Every field except `proposed_edit` matches the /3 response envelope exactly. +#[derive(Serialize, Deserialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub(crate) struct ResponseDocumentV4 { + /// Exact forge.review-response/4 version. + pub(crate) schema_version: String, + /// Mandatory asserted-only identity disclaimer. + pub(crate) identity_disclaimer: String, + /// Explicit unique caller response UUID. + pub(crate) response_id: String, + /// Referenced queue UUID. + pub(crate) queue_id: String, + /// Exact original queue package hash. + pub(crate) queue_raw_sha256: String, + /// Selected item key. + pub(crate) item_key: String, + /// Selected item UUID. + pub(crate) item_id: String, + /// Exact selected domain. + pub(crate) domain: DomainV3, + /// Exact selected adapter version. + pub(crate) adapter_version: String, + /// Exact selected re-review action. + pub(crate) requested_action: RequestedAction, + /// Complete queue source-pin set; no detached currentness. + pub(crate) source_pins: Vec, + /// Exact subject binding. + pub(crate) subject_sha256: String, + /// Exact minimized context binding. + pub(crate) context_sha256: String, + /// Exact complete policy binding. + pub(crate) policy_sha256: String, + /// Asserted reviewer key. + pub(crate) reviewer_key: String, + /// Asserted role for this response. + pub(crate) reviewer_role: String, + /// Preserved independent disposition. + pub(crate) disposition: Disposition, + /// Explicit canonical UTC seconds. + pub(crate) responded_at: String, + /// Private rationale, at most eight KiB UTF-8. + pub(crate) rationale: String, + /// Explicit documented abstention reason; otherwise null. + pub(crate) abstention_reason: Option, + /// Optional inert proposed edit; null preserves the zero-edit behavior. + pub(crate) proposed_edit: Option, + /// Explicit bound prior reference only for superseded disposition. + pub(crate) supersedes: Option, +} + +#[cfg(test)] +#[path = "wire_v4_tests.rs"] +mod tests; diff --git a/src/review/wire_v4_tests.rs b/src/review/wire_v4_tests.rs new file mode 100644 index 00000000..08ffe172 --- /dev/null +++ b/src/review/wire_v4_tests.rs @@ -0,0 +1,64 @@ +//! Closed edit-capable /4 declaration shape controls: the optional inert edit slot and +//! the single closed patch format. These are asserted data shapes, never native proof. +use super::{PatchFormat, ProposedEdit, RESPONSE_VERSION}; +use crate::hashing::sha256_hex; +use serde_json::{Value, json}; + +/// One inert proposed edit bound to a subject, with an exact patch digest. +fn edit() -> ProposedEdit { + let patch = "# Replacement text\n"; + ProposedEdit { + target_subject_sha256: "b".repeat(64), + patch_format: PatchFormat::FullText, + patch: patch.into(), + patch_sha256: sha256_hex(patch.as_bytes()), + } +} + +/// The proposed edit serializes to the closed kebab-case envelope with all four fields. +#[test] +fn proposed_edit_serializes_closed_envelope() { + let value = serde_json::to_value(edit()).unwrap(); + assert_eq!(value["patch_format"], "full-text"); + assert_eq!(value["target_subject_sha256"], "b".repeat(64)); + assert_eq!(value["patch"], "# Replacement text\n"); + assert_eq!(value["patch_sha256"], sha256_hex(b"# Replacement text\n")); + assert_eq!(value.as_object().unwrap().len(), 4); +} + +/// The edit slot is optional: null preserves the zero-edit behavior, present retains the patch. +#[test] +fn edit_slot_is_optional() { + let null: Value = serde_json::from_str("null").unwrap(); + let absent: Option = serde_json::from_value(null).unwrap(); + assert!(absent.is_none()); + let present: Option = + serde_json::from_value(serde_json::to_value(edit()).unwrap()).unwrap(); + assert_eq!(present.unwrap().patch, "# Replacement text\n"); +} + +/// The closed envelope refuses unknown fields; no detached edit channel is admitted. +#[test] +fn proposed_edit_denies_unknown_fields() { + let value = json!({ + "target_subject_sha256": "b".repeat(64), + "patch_format": "full-text", + "patch": "# text\n", + "patch_sha256": sha256_hex(b"# text\n"), + "apply_now": true + }); + assert!(serde_json::from_value::(value).is_err()); +} + +/// The patch format is a single closed enum; no multi-format registry is admitted. +#[test] +fn patch_format_is_closed() { + assert!(serde_json::from_value::(json!("full-text")).is_ok()); + assert!(serde_json::from_value::(json!("unified-diff")).is_err()); +} + +/// The response version token is the separately closed /4 family, never /3. +#[test] +fn response_version_is_closed_v4() { + assert_eq!(RESPONSE_VERSION, "forge.review-response/4"); +} From 33d4bfd29cc602504dd5d058e4a34d7ee33d1976 Mon Sep 17 00:00:00 2001 From: Brian Luby Date: Sat, 14 Nov 2026 14:48:51 -0800 Subject: [PATCH 2/2] fix(review): enforce 64 KiB patch byte bound on /4 decode and fix /3 doc typos - Enforce nonempty + MAX_PATCH_BYTES byte bound for proposed_edit.patch in response_operands, closing the gap where schema maxLength (chars) let a multibyte patch over 64 KiB bytes pass decode_response; reuse the shared constant in the respond writer path too. - Regression test: 32769 two-byte chars (under maxLength, over byte bound) refused by both the typed validator and raw decode admission. - Doc typos: dispositions-4 schema description, decode_v4_operational Response/4 + Dispositions/4 comments, edit_response and edit_response_binding headers, CLI 'at most 8/64 KiB' spacing. --- .../forge.review-dispositions-4.schema.json | 2 +- src/cli/mod.rs | 4 +-- src/review/decode_v4_operational.rs | 4 +-- src/review/decode_v4_tests.rs | 25 +++++++++++++++++++ src/review/edit_response.rs | 6 ++--- src/review/edit_response_binding.rs | 4 +-- src/review/encode_v4_operational.rs | 4 +++ 7 files changed, 39 insertions(+), 10 deletions(-) diff --git a/schemas/forge.review-dispositions-4.schema.json b/schemas/forge.review-dispositions-4.schema.json index fa29350e..4d49aa41 100644 --- a/schemas/forge.review-dispositions-4.schema.json +++ b/schemas/forge.review-dispositions-4.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "forge.review-dispositions/4", "title": "forge.review-dispositions/4", - "description": "Proposed separately closed whole authoring-plan /3 exchange. Inert asserted declarations only; structural shape does not supply native preparation, alias/currentness/capture, authenticated identity or approval. Complete UTF-8 byte limits and all semantic correlations require the typed contract.", + "description": "Proposed separately closed whole authoring-plan /4 exchange. Inert asserted declarations only; structural shape does not supply native preparation, alias/currentness/capture, authenticated identity or approval. Complete UTF-8 byte limits and all semantic correlations require the typed contract.", "$ref": "#/$defs/DispositionsDocument", "$defs": { "key": { diff --git a/src/cli/mod.rs b/src/cli/mod.rs index 065d6e4c..b227d011 100644 --- a/src/cli/mod.rs +++ b/src/cli/mod.rs @@ -3358,7 +3358,7 @@ pub struct EditReviewRespondArgs { /// Explicit canonical response UUID #[arg(long)] pub response_id: String, - /// Confined UTF-8 private rationale file, at most8 KiB + /// Confined UTF-8 private rationale file, at most 8 KiB #[arg(long)] pub rationale_file: PathBuf, /// Explicit policy-defined reason permitting an empty abstention rationale @@ -3370,7 +3370,7 @@ pub struct EditReviewRespondArgs { /// Exact SHA-256 of the previous response original; requires its UUID #[arg(long, requires = "supersedes_id")] pub supersedes_sha256: Option, - /// Confined UTF-8 proposed replacement patch file, at most64 KiB; inert until promoted + /// Confined UTF-8 proposed replacement patch file, at most 64 KiB; inert until promoted #[arg(long)] pub proposed_patch: Option, /// Confined new response file; existing destinations are refused diff --git a/src/review/decode_v4_operational.rs b/src/review/decode_v4_operational.rs index 48a1c48e..c9ad6f28 100644 --- a/src/review/decode_v4_operational.rs +++ b/src/review/decode_v4_operational.rs @@ -167,7 +167,7 @@ pub(crate) fn dispositions( counters(document, ledger) }) } -/// Decode actual borrowed original Response/3 bytes, preserving preflight registration/edit order. +/// Decode actual borrowed original Response/4 bytes, preserving preflight registration/edit order. pub(crate) fn decode_response<'a>( raw: &'a [u8], ledger: &mut ContractLedger, @@ -186,7 +186,7 @@ pub(crate) fn decode_response<'a>( Ok(DecodedV3::from_admitted(raw, raw_sha256, document)) }) } -/// Decode complete recorded Dispositions/3 claims, without issuing currentness or approval. +/// Decode complete recorded Dispositions/4 claims, without issuing currentness or approval. pub(crate) fn decode_dispositions<'a>( raw: &'a [u8], ledger: &mut ContractLedger, diff --git a/src/review/decode_v4_tests.rs b/src/review/decode_v4_tests.rs index 732f319e..cba2dc41 100644 --- a/src/review/decode_v4_tests.rs +++ b/src/review/decode_v4_tests.rs @@ -123,6 +123,31 @@ fn valid_response_passes_typed_validator() { .expect("valid edit-capable response"); } +/// A multibyte patch under the character-based schema maxLength but over the 64 KiB +/// UTF-8 byte bound is refused by the typed validator and by raw decode admission. +#[test] +fn multibyte_patch_over_byte_bound_is_refused() { + let patch = "é".repeat(32 * 1024 + 1); + assert!(patch.chars().count() < 65_536); + assert!(patch.len() > 64 * 1024); + let mut document = document(); + document.proposed_edit = Some(ProposedEdit { + target_subject_sha256: "b".repeat(64), + patch_format: PatchFormat::FullText, + patch_sha256: sha256_hex(patch.as_bytes()), + patch, + }); + assert!(matches!( + refusal(response(&document, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); + let bytes = raw(&document); + assert!(matches!( + refusal(decode_response(&bytes, &mut ContractLedger::default(), &mut NoopControl)), + ContractError::Invalid + )); +} + /// The closed schema refuses an unknown edit field before Serde admits the document. #[test] fn unknown_edit_field_is_refused_by_schema() { diff --git a/src/review/edit_response.rs b/src/review/edit_response.rs index 391ee0ec..9ce80f76 100644 --- a/src/review/edit_response.rs +++ b/src/review/edit_response.rs @@ -1,4 +1,4 @@ -//! Ordinary Authoring Response/3 from complete held Queue and private rationale. +//! Ordinary Authoring Response/4 from complete held Queue and private rationale. //! Assertions preserve recorded bindings and never issue native currentness. use super::{command_phase, publish}; use crate::evidence_capture::CaptureRole; @@ -158,7 +158,7 @@ fn build_response( let proposed_edit = match options.proposed_patch { None => None, Some(patch) => { - if patch.len() > 64 * 1024 { + if patch.len() > edit_response_binding::MAX_PATCH_BYTES { return Err(ledger.capacity()); } ledger.bytes(patch.len())?; @@ -170,7 +170,7 @@ fn build_response( Some(ProposedEdit { target_subject_sha256: copied(&item.subject_sha256, 64, ledger, control)?, patch_format: PatchFormat::FullText, - patch: copied(patch, 64 * 1024, ledger, control)?, + patch: copied(patch, edit_response_binding::MAX_PATCH_BYTES, ledger, control)?, patch_sha256, }) } diff --git a/src/review/edit_response_binding.rs b/src/review/edit_response_binding.rs index d4811440..4406168e 100644 --- a/src/review/edit_response_binding.rs +++ b/src/review/edit_response_binding.rs @@ -1,4 +1,4 @@ -//! A-authored ordinary /3 binding and complete raw-original relation. +//! A-authored ordinary /4 binding and complete raw-original relation. //! These declarations/correlations authenticate no reviewer or native currentness. use super::decode::{ContractError, ContractLedger, OriginalRelation}; use super::decode_v2::phase; @@ -95,7 +95,7 @@ fn eligible( Ok(membership && !author && assigned) } /// Maximum bounded proposed patch text, in UTF-8 bytes (PRD 068 M-10 envelope). -const MAX_PATCH_BYTES: usize = 64 * 1024; +pub(crate) const MAX_PATCH_BYTES: usize = 64 * 1024; /// Structural edit-envelope syntax: bounded nonempty patch, exact digest grammar and /// exact patch-byte integrity. Deliberately does NOT check the target binding, so a diff --git a/src/review/encode_v4_operational.rs b/src/review/encode_v4_operational.rs index 6068ed27..b41eeb16 100644 --- a/src/review/encode_v4_operational.rs +++ b/src/review/encode_v4_operational.rs @@ -1,6 +1,7 @@ //! Finite separately closed plain Response/4 and Dispositions/4 output/readback. use crate::review::decode::{ContractError, ContractLedger}; use crate::review::decode_v2::{checkpoint, phase}; +use crate::review::edit_response_binding::MAX_PATCH_BYTES; use crate::review::encode_v3::{fixed, optional, pin, strings, text}; use crate::review::wire_v4::{ DispositionCounts, DispositionsDocumentV4, ItemDisposition, MetSeat, RecordedResponse, @@ -66,6 +67,9 @@ pub(crate) fn response_operands( text(&edit.patch, ledger)?; text(&edit.patch_sha256, ledger)?; fixed(1, ledger)?; + if edit.patch.is_empty() || edit.patch.len() > MAX_PATCH_BYTES { + return Err(ContractError::Invalid); + } } if let Some(value) = supersedes { text(&value.response_id, ledger)?;