fix(warp-core): recognize create-from-absence patch shape in WAL recovery

operation_patch_scope_v1 only recognized the single-SetAttachment-op
update shape. A create-from-absence patch (WarpOp::UpsertNode then
WarpOp::SetAttachment, two-element out_slots) never matched, so
validate_operation_receipt_state_delta rejected every durable
create-from-absence commit with EchoOperationExecutionMismatch --
not only on recovery by a fresh host, but synchronously at the
original commit whenever the runtime WAL is enabled.

Found by Codex's automated review on PR #686. Extended the function
to recognize both canonical patch shapes explicitly, rather than
adding a second unrelated function, since both are the same
program's only two possible outputs.

RED: filesystem_wal_recovers_a_create_from_absence_commit failed at
commit_prepared_echo_operation_v1 with exactly this error before the
fix. GREEN: same test now passes; full pipeline suite (20 tests) and
existing update-path WAL recovery test both remain green.

Author: flyingrobots

crates/warp-core/src/trusted_runtime_host.rs

@@ -3163,25 +3163,57 @@ fn recover_echo_operation_material(
     })
 }
 
+/// Recognizes the two canonical patch shapes the anchored-node-attachment
+/// compare-and-set program produces: an update (`SetAttachment` alone) and,
+/// since ADR 0024, a create-from-absence (`UpsertNode` then `SetAttachment`,
+/// writing both slots). Anything else -- including either op alone, either
+/// op out of order, or a mismatched key/owner -- does not scope to a node.
 fn operation_patch_scope_v1(patch: &crate::WorldlineTickPatchV1) -> Option<crate::NodeKey> {
-    let [crate::WarpOp::SetAttachment { key, .. }] = patch.ops.as_slice() else {
-        return None;
-    };
-    let crate::AttachmentOwner::Node(node) = key.owner else {
-        return None;
+    let node = match patch.ops.as_slice() {
+        [crate::WarpOp::SetAttachment { key, .. }] => {
+            let crate::AttachmentOwner::Node(node) = key.owner else {
+                return None;
+            };
+            let attachment_slot = crate::AttachmentKey::node_alpha(node);
+            if *key != attachment_slot
+                || patch.warp_id != node.warp_id
+                || patch.in_slots.as_slice()
+                    != [
+                        crate::SlotId::Node(node),
+                        crate::SlotId::Attachment(attachment_slot),
+                    ]
+                || patch.out_slots.as_slice() != [crate::SlotId::Attachment(attachment_slot)]
+            {
+                return None;
+            }
+            node
+        }
+        [crate::WarpOp::UpsertNode { node, .. }, crate::WarpOp::SetAttachment { key, .. }] => {
+            let node = *node;
+            let crate::AttachmentOwner::Node(attachment_node) = key.owner else {
+                return None;
+            };
+            let attachment_slot = crate::AttachmentKey::node_alpha(node);
+            if attachment_node != node
+                || *key != attachment_slot
+                || patch.warp_id != node.warp_id
+                || patch.in_slots.as_slice()
+                    != [
+                        crate::SlotId::Node(node),
+                        crate::SlotId::Attachment(attachment_slot),
+                    ]
+                || patch.out_slots.as_slice()
+                    != [
+                        crate::SlotId::Node(node),
+                        crate::SlotId::Attachment(attachment_slot),
+                    ]
+            {
+                return None;
+            }
+            node
+        }
+        _ => return None,
     };
-    let attachment_slot = crate::AttachmentKey::node_alpha(node);
-    if *key != attachment_slot
-        || patch.warp_id != node.warp_id
-        || patch.in_slots.as_slice()
-            != [
-                crate::SlotId::Node(node),
-                crate::SlotId::Attachment(attachment_slot),
-            ]
-        || patch.out_slots.as_slice() != [crate::SlotId::Attachment(attachment_slot)]
-    {
-        return None;
-    }
     Some(node)
 }
 

crates/warp-core/tests/executable_operation_pipeline_tests.rs

@@ -2080,3 +2080,79 @@ fn create_from_absence_cannot_commit_after_its_parent_basis_changes() {
         )))
     );
 }
+
+/// Regression for PR #686 review finding #1 (Codex, P0): a durably committed
+/// create-from-absence patch (WarpOp::UpsertNode + WarpOp::SetAttachment,
+/// two-element out_slots) must be recoverable by a fresh host, exactly like
+/// an update-shaped patch already is.
+#[test]
+fn filesystem_wal_recovers_a_create_from_absence_commit() {
+    let wal_dir = TempWalDir::new();
+    let attachment_type = make_type_id("operation-fixture-atom");
+    let new_node = NodeKey {
+        warp_id: make_warp_id("operation-fixture"),
+        local_id: make_node_id("operation-fixture-wal-created"),
+    };
+    let application_basis =
+        warp_core::echo_operation_anchored_node_absent_application_basis_v1(new_node);
+
+    {
+        let (mut host, head_key, _existing_node) = fixture_host();
+        host.enable_runtime_wal(TrustedRuntimeWalConfig::filesystem(wal_dir.path()))
+            .expect("the fresh filesystem WAL opens");
+        let installed = install_fixture_operation(&mut host);
+        let evaluation_basis = host
+            .echo_operation_evaluation_basis_v1(head_key, application_basis)
+            .expect("Echo resolves the exact current parent basis");
+        let invocation = EchoOperationInvocationV1::anchored_node_attachment_compare_and_set(
+            installed.package_id(),
+            installed.operation_coordinate(),
+            evaluation_basis,
+            digest("fixture-authority-grant"),
+            EchoOperationBudgetV1::new(16, 4_096, 4_096),
+            new_node,
+            None,
+            b"wal-created".to_vec(),
+        );
+        let invocation_bytes = invocation.to_canonical_bytes().expect("invocation encodes");
+        let admitted = host
+            .admit_echo_operation_invocation_v1(
+                &EchoOperationInvocationAdmissionPolicyV1::new(
+                    digest("fixture-authority-profile"),
+                    digest("fixture-authority-grant"),
+                    EchoOperationBudgetV1::new(16, 4_096, 4_096),
+                ),
+                &invocation_bytes,
+            )
+            .expect("the create-from-absence invocation is independently admitted");
+        let EchoOperationPreparationV1::Prepared(prepared) =
+            host.prepare_echo_operation_v1(admitted)
+        else {
+            panic!("the lawful create-from-absence invocation must prepare");
+        };
+        host.commit_prepared_echo_operation_v1(prepared)
+            .expect("the durable create-from-absence operation commits");
+    }
+
+    let (mut recovered, head_key, _existing_node) = fixture_host();
+    recovered
+        .enable_runtime_wal(TrustedRuntimeWalConfig::filesystem(wal_dir.path()))
+        .expect(
+            "a fresh host recovers a create-from-absence commit without replaying application code",
+        );
+    let state = recovered
+        .runtime()
+        .worldlines()
+        .get(&head_key.worldline_id)
+        .expect("the recovered worldline exists")
+        .state();
+    assert_eq!(
+        state
+            .store(&new_node.warp_id)
+            .and_then(|store| store.node_attachment(&new_node.local_id)),
+        Some(&AttachmentValue::Atom(AtomPayload::new(
+            attachment_type,
+            Bytes::from_static(b"wal-created"),
+        )))
+    );
+}