@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/order-risk.js

@@ -0,0 +1,653 @@
+import { MAX_AGENT_COUNT, MAX_DISPUTE_COUNT, } from "@wowok/wowok";
+import { findSceneById, } from "./order-ledger.js";
+const R_O_1_01 = {
+    id: "R-O-1-01",
+    category: "structural",
+    trigger: "Order has 14 fields but no Permission field (unique among 22 objects)",
+    check: (ctx) => {
+        if (ctx.is_buy_operation) {
+            return {
+                id: "R-O-1-01",
+                level: "LOW",
+                category: "structural",
+                title: "Order uses owner/agent dual-layer (no Permission)",
+                description: "Order is the only business object among 22 WoWok objects that does NOT use the Permission system. All access control flows through assert_owner and has_op_permission inline functions.",
+                affected_stakeholders: ["system", "owner", "agent"],
+                scenario: "Developer assumes Order uses Permission and writes permission::check logic",
+                mitigation: "Use owner/agent checks directly. Do NOT attempt to apply a Permission object to Order.",
+                evidence: "no_permission_field",
+            };
+        }
+        return null;
+    },
+};
+const R_O_1_02 = {
+    id: "R-O-1-02",
+    category: "structural",
+    trigger: "Item count check (informational; no Move-level limit on items)",
+    check: (ctx) => {
+        if (!ctx.items || ctx.items.length === 0)
+            return null;
+        if (ctx.items.length > 50) {
+            return {
+                id: "R-O-1-02",
+                level: "LOW",
+                category: "structural",
+                title: "Large items list may exceed tx size limits",
+                description: `${ctx.items.length} items in a single Order — no protocol limit, but large lists increase transaction size and may hit gas/size limits`,
+                affected_stakeholders: ["owner"],
+                scenario: "Bulk purchase with many line items",
+                mitigation: "Split into multiple Orders if items > 50",
+                evidence: `items_count=${ctx.items.length}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_1_03 = {
+    id: "R-O-1-03",
+    category: "structural",
+    trigger: "dispute count >= MAX_DISPUTE_COUNT (10)",
+    check: (ctx) => {
+        const count = ctx.current_dispute_count ?? 0;
+        if (count >= MAX_DISPUTE_COUNT) {
+            return {
+                id: "R-O-1-03",
+                level: "HIGH",
+                category: "structural",
+                title: "Dispute count at MAX_DISPUTE_COUNT limit",
+                description: `Order already has ${count} disputes (MAX_DISPUTE_COUNT=${MAX_DISPUTE_COUNT}). Next dispute() call will abort E_DISPUTE_COUNT_EXCEEDED.`,
+                affected_stakeholders: ["owner", "agent", "arbitrator"],
+                scenario: "Filing 11th dispute on an Order with 10 existing disputes",
+                mitigation: "Resolve existing disputes (via arb_claim_compensation) before filing new ones. Note: claimed_by blocks ALL future disputes.",
+                evidence: `dispute_count=${count}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_1_04 = {
+    id: "R-O-1-04",
+    category: "structural",
+    trigger: "agent count > MAX_AGENT_COUNT (doc=10, actual allows 11 due to <= bug)",
+    check: (ctx) => {
+        if (!ctx.agent_set)
+            return null;
+        const count = ctx.agent_set.agents.length;
+        if (count > MAX_AGENT_COUNT) {
+            return {
+                id: "R-O-1-04",
+                level: "HIGH",
+                category: "structural",
+                title: "Agent count exceeds documented MAX_AGENT_COUNT (boundary bug)",
+                description: `Attempting to set ${count} agents. Doc says MAX_AGENT_COUNT=${MAX_AGENT_COUNT}, but Move agent_set_imp uses <= instead of <, actually allowing 11. SDK constant = ${MAX_AGENT_COUNT} does not match chain behavior.`,
+                affected_stakeholders: ["owner", "system"],
+                scenario: "Setting 11 agents — succeeds on chain but contradicts SDK/docs",
+                mitigation: "Treat 10 as the soft cap (matching docs). If 11 is intentional, document the boundary bug explicitly. Long-term: fix Move to use < and sync SDK.",
+                evidence: `agent_count=${count}, max_doc=${MAX_AGENT_COUNT}, max_actual=11`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_1_05 = {
+    id: "R-O-1-05",
+    category: "structural",
+    trigger: "wip_hash is empty string in any item",
+    check: (ctx) => {
+        if (!ctx.items)
+            return null;
+        const emptyHashItem = ctx.items.find(i => !i.wip_hash || i.wip_hash === "");
+        if (emptyHashItem) {
+            return {
+                id: "R-O-1-05",
+                level: "HIGH",
+                category: "structural",
+                title: "Empty wip_hash in item",
+                description: `Item "${emptyHashItem.name}" has empty wip_hash. Move rejects empty strings (F-O-18).`,
+                affected_stakeholders: ["owner"],
+                scenario: "User submits item without computing WIP hash",
+                mitigation: "Compute wip_hash from the work-in-progress file content before service::buy().",
+                evidence: `item_name=${emptyHashItem.name}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_2_01 = {
+    id: "R-O-2-01",
+    category: "semantic",
+    trigger: "Order.machine snapshot differs from current Service.machine",
+    check: (ctx) => {
+        if (!ctx.current_service_machine || !ctx.order_machine_snapshot)
+            return null;
+        if (ctx.current_service_machine !== ctx.order_machine_snapshot) {
+            return {
+                id: "R-O-2-01",
+                level: "HIGH",
+                category: "semantic",
+                title: "Machine snapshot diverges from Service.machine",
+                description: `Order.machine=${ctx.order_machine_snapshot} was snapshotted at buy time. Service.machine is now ${ctx.current_service_machine}. Same Service has Orders running different Machine versions.`,
+                affected_stakeholders: ["owner", "service_provider", "arbitrator"],
+                scenario: "Service provider upgrades Machine after some Orders are created",
+                mitigation: "Audit each Order's machine snapshot separately. Document Machine version per Order. Plan migration paths for legacy Orders.",
+                evidence: `order_machine=${ctx.order_machine_snapshot}, service_machine=${ctx.current_service_machine}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_2_02 = {
+    id: "R-O-2-02",
+    category: "semantic",
+    trigger: "SDK uses 'builder' field for Move's 'owner' field (naming deviation)",
+    check: (ctx) => {
+        if (ctx.object) {
+            return {
+                id: "R-O-2-02",
+                level: "MEDIUM",
+                category: "semantic",
+                title: "SDK builder ≠ Move owner (only naming deviation in 22 objects)",
+                description: "SDK ObjectOrder.builder corresponds to Move Order.owner. This is the only field name deviation across all 22 WoWok objects. All Order knowledge uses Move's 'owner' as canonical.",
+                affected_stakeholders: ["system"],
+                scenario: "Developer reads SDK 'builder' and assumes it's a different concept from owner",
+                mitigation: "Use moveToSdkField()/sdkToMoveField() helpers from order-ledger.ts. Document 'builder = owner' in all SDK consumers.",
+                evidence: "sdk_field=builder, move_field=owner",
+            };
+        }
+        return null;
+    },
+};
+const R_O_2_03 = {
+    id: "R-O-2-03",
+    category: "semantic",
+    trigger: "owner_change or agent_set aborted with E_PROGRESS_NOT_SPECIFIED (dual semantics)",
+    check: (ctx) => {
+        if (!ctx.operation)
+            return null;
+        if ((ctx.operation === "agent_set") && ctx.progress_bound) {
+            return {
+                id: "R-O-2-03",
+                level: "MEDIUM",
+                category: "semantic",
+                title: "E_PROGRESS_NOT_SPECIFIED dual semantics (literal vs actual)",
+                description: "agent_set aborted because progress.is_some() — but error code says 'PROGRESS_NOT_SPECIFIED'. The code is used in two OPPOSITE scenarios: (A) progress.is_none() during on_progress (literal), (B) progress.is_some() during owner_change/agent_set (opposite).",
+                affected_stakeholders: ["owner", "agent"],
+                scenario: "User sees 'Progress not specified' error when Progress IS specified — confusion",
+                mitigation: "Translate error to: 'Cannot modify owner/agent: Progress already bound (frozen).' Long-term: split into two error codes (E_PROGRESS_ALREADY_BOUND and E_PROGRESS_NOT_SPECIFIED).",
+                evidence: `operation=${ctx.operation}, progress_bound=${ctx.progress_bound}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_2_04 = {
+    id: "R-O-2-04",
+    category: "semantic",
+    trigger: "SaleItem.item → PurchasedItem.name field name mapping",
+    check: (ctx) => {
+        if (ctx.is_buy_operation) {
+            return {
+                id: "R-O-2-04",
+                level: "LOW",
+                category: "semantic",
+                title: "SaleItem.item (Move) maps to PurchasedItem.name (SDK)",
+                description: "Move struct SaleItem uses field 'item', but SDK ObjectOrder.items uses field 'name'. This is the second naming deviation in Order system (after builder/owner).",
+                affected_stakeholders: ["system"],
+                scenario: "Cross-layer data mapping between Move and SDK",
+                mitigation: "Use consistent SDK field names in user-facing code; document Move ↔ SDK mapping in audit logs.",
+                evidence: "move_field=SaleItem.item, sdk_field=PurchasedItem.name",
+            };
+        }
+        return null;
+    },
+};
+const R_O_3_01 = {
+    id: "R-O-3-01",
+    category: "authority",
+    trigger: "Agent attempts receive or transfer_to (L1 owner-only operations)",
+    check: (ctx) => {
+        if (!ctx.operation)
+            return null;
+        if ((ctx.operation === "receive" || ctx.operation === "transfer_to") &&
+            ctx.caller_is_agent && !ctx.caller_is_owner) {
+            return {
+                id: "R-O-3-01",
+                level: "HIGH",
+                category: "authority",
+                title: "Agent attempting owner-only operation",
+                description: `Agent cannot call ${ctx.operation} — these are L1 owner-only operations (assert_owner). Agent can operate progress/arb_*/required_info but CANNOT receive funds or transfer ownership.`,
+                affected_stakeholders: ["agent", "owner"],
+                scenario: "Logistics agent tries to collect payment on behalf of buyer",
+                mitigation: "Owner must call receive/transfer_to directly. If delegation is needed, owner can transfer_to a multi-sig wallet that includes the agent.",
+                evidence: `operation=${ctx.operation}, caller=agent`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_3_02 = {
+    id: "R-O-3-02",
+    category: "authority",
+    trigger: "Non-owner non-agent attempts operation (no permission)",
+    check: (ctx) => {
+        if (!ctx.operation)
+            return null;
+        if (ctx.caller_is_owner === false && ctx.caller_is_agent === false) {
+            return {
+                id: "R-O-3-02",
+                level: "HIGH",
+                category: "authority",
+                title: "Non-owner non-agent attempting operation",
+                description: `Caller is neither owner nor agent. All Order operations require at least has_op_permission (L2 layer). Aborts E_PERMISSION.`,
+                affected_stakeholders: ["system"],
+                scenario: "Random address attempts to advance someone else's Order",
+                mitigation: "Verify caller is owner or in agent[] before submitting transaction.",
+                evidence: `operation=${ctx.operation}, caller=unauthorized`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_3_03 = {
+    id: "R-O-3-03",
+    category: "authority",
+    trigger: "arb_claim_compensation called (sets claimed_by, irreversible)",
+    check: (ctx) => {
+        if (ctx.operation !== "arb_claim_compensation")
+            return null;
+        return {
+            id: "R-O-3-03",
+            level: "HIGH",
+            category: "authority",
+            title: "arb_claim_compensation is IRREVERSIBLE (claimed_by one-time set)",
+            description: "Setting claimed_by is permanent. After this call: (1) claimed_by cannot be reset, (2) NO new disputes can be filed (E_ORDER_ALREADY_CLAIMED), (3) all unresolved disputes become unactionable. If first compensation is insufficient, buyer has no recourse.",
+            affected_stakeholders: ["owner", "agent", "arbitrator"],
+            scenario: "Buyer claims partial compensation, then discovers additional damages",
+            mitigation: "BEFORE claiming: (1) enumerate ALL disputes, (2) ensure proposition covers all damages, (3) confirm Arb ruling is final. Add explicit user confirmation (C-O-08).",
+            evidence: `operation=arb_claim_compensation, current_claimed_by=${ctx.claimed_by_set ?? false}`,
+        };
+    },
+};
+const R_O_3_04 = {
+    id: "R-O-3-04",
+    category: "authority",
+    trigger: "dispute attempted after claimed_by is set",
+    check: (ctx) => {
+        if (ctx.claimed_by_set && (ctx.operation === "arb_confirm" || ctx.operation === "arb_objection")) {
+            return {
+                id: "R-O-3-04",
+                level: "HIGH",
+                category: "authority",
+                title: "Cannot file new dispute after claimed_by is set",
+                description: "Order.claimed_by is set — any new dispute() call aborts E_ORDER_ALREADY_CLAIMED. arb_confirm/arb_objection trigger dispute() internally.",
+                affected_stakeholders: ["owner", "agent"],
+                scenario: "Buyer claims compensation then tries to file additional dispute",
+                mitigation: "Resolve ALL disputes BEFORE calling arb_claim_compensation. claimed_by is terminal for dispute flow.",
+                evidence: `operation=${ctx.operation}, claimed_by_set=true`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_01 = {
+    id: "R-O-4-01",
+    category: "lifecycle",
+    trigger: "Attempt to create Order independently (not via service::buy)",
+    check: (ctx) => {
+        if (ctx.is_buy_operation === false && ctx.operation === "service_buy" && !ctx.object) {
+            return {
+                id: "R-O-4-01",
+                level: "CRITICAL",
+                category: "lifecycle",
+                title: "Order cannot be created independently (compound creation only)",
+                description: "order::new() is package-only — only service::buy() can create Orders. Any attempt to call order::new directly will fail at the Move module boundary. Order + Allocation + Progress are created atomically in one transaction.",
+                affected_stakeholders: ["system", "owner"],
+                scenario: "Developer tries to construct Order independently for testing",
+                mitigation: "Always use service::buy() to create Orders. For testing, deploy a minimal Service with machine/allocators configured.",
+                evidence: "independent_creation_attempted",
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_02 = {
+    id: "R-O-4-02",
+    category: "lifecycle",
+    trigger: "agent_set or owner_change attempted after Progress binding",
+    check: (ctx) => {
+        if (!ctx.operation)
+            return null;
+        if ((ctx.operation === "agent_set") && ctx.progress_bound) {
+            return {
+                id: "R-O-4-02",
+                level: "HIGH",
+                category: "lifecycle",
+                title: "agent_set blocked — Progress binding frozen owner/agent",
+                description: "Once order.progress is set (during service::buy if Service has machine), agent_set and owner_change abort E_PROGRESS_NOT_SPECIFIED. Owner/agent must be finalized BEFORE buy.",
+                affected_stakeholders: ["owner", "agent"],
+                scenario: "Buyer wants to add agent mid-fulfillment after Progress is bound",
+                mitigation: "Set agent list BEFORE service::buy (via pre-buy configuration). If post-buy agent change is needed, use transfer_to a new owner who has the desired agents.",
+                evidence: `operation=agent_set, progress_bound=${ctx.progress_bound}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_03 = {
+    id: "R-O-4-03",
+    category: "lifecycle",
+    trigger: "Progress advance attempted without progress bound",
+    check: (ctx) => {
+        if (ctx.operation === "progress_advance" && ctx.progress_bound === false) {
+            return {
+                id: "R-O-4-03",
+                level: "HIGH",
+                category: "lifecycle",
+                title: "Cannot advance Progress — no Progress bound to Order",
+                description: "Order has no progress field set (Service had no machine configured). Cannot advance a non-existent Progress. SDK CallOrder validates this pre-flight (CallOrder_Data.progress requires order.machine and order.progress).",
+                affected_stakeholders: ["owner", "agent"],
+                scenario: "Buyer tries to advance Progress on an Order created from a Service without machine",
+                mitigation: "Use a Service with machine configured. If manual lifecycle is needed, track state off-chain.",
+                evidence: `operation=progress_advance, progress_bound=false`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_04 = {
+    id: "R-O-4-04",
+    category: "lifecycle",
+    trigger: "arb_confirm/arb_objection/arb_claim_compensation (irreversible Arb operations)",
+    check: (ctx) => {
+        if (!ctx.operation)
+            return null;
+        if (ctx.operation === "arb_confirm" || ctx.operation === "arb_objection" || ctx.operation === "arb_claim_compensation") {
+            return {
+                id: "R-O-4-04",
+                level: "HIGH",
+                category: "lifecycle",
+                title: `${ctx.operation} is irreversible (triggers Arb flow)`,
+                description: `${ctx.operation} triggers the Arbitration workflow which cannot be undone. arb_confirm files a new dispute, arb_objection requests re-arbitration, arb_claim_compensation sets claimed_by permanently.`,
+                affected_stakeholders: ["owner", "agent", "arbitrator"],
+                scenario: "User accidentally files arb_confirm without understanding consequences",
+                mitigation: "Add explicit user confirmation (C-O-08, C-O-11, C-O-12) before these operations. Show warning text describing irreversibility.",
+                evidence: `operation=${ctx.operation}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_05 = {
+    id: "R-O-4-05",
+    category: "lifecycle",
+    trigger: "receive attempted while Progress not at terminal node",
+    check: (ctx) => {
+        if (ctx.operation === "receive" && ctx.progress_bound && !ctx.progress_at_terminal) {
+            return {
+                id: "R-O-4-05",
+                level: "HIGH",
+                category: "lifecycle",
+                title: "receive blocked — Order still delivering (E_ORDER_DELIVERING)",
+                description: "owner_receive aborts E_ORDER_DELIVERING when Progress has not reached a terminal node. Funds cannot be collected until fulfillment completes.",
+                affected_stakeholders: ["owner"],
+                scenario: "Buyer tries to collect refund before Progress reaches 'completed' or 'cancelled'",
+                mitigation: "Wait for Progress to reach terminal/cancel node. If urgent, file arb_confirm to dispute.",
+                evidence: `operation=receive, progress_at_terminal=${ctx.progress_at_terminal}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_4_06 = {
+    id: "R-O-4-06",
+    category: "lifecycle",
+    trigger: "transfer_to attempted (irreversible ownership transfer)",
+    check: (ctx) => {
+        if (ctx.operation !== "transfer_to")
+            return null;
+        return {
+            id: "R-O-4-06",
+            level: "CRITICAL",
+            category: "lifecycle",
+            title: "transfer_to is IRREVERSIBLE — new owner takes over ALL permissions",
+            description: `Ownership transfer to ${ctx.transfer_to_new_owner ?? "(unknown)"} is permanent. New owner becomes the sole receiver of payments and gains full L1 control. Original owner loses ALL access.`,
+            affected_stakeholders: ["owner"],
+            scenario: "Buyer transfers Order to wrong address by mistake",
+            mitigation: "1) Verify new owner address twice. 2) Coordinate with new owner before transfer. 3) Add explicit user confirmation (C-O-09). Note: transfer_to is NOT blocked by progress binding (unlike agent_set).",
+            evidence: `new_owner=${ctx.transfer_to_new_owner}`,
+        };
+    },
+};
+const R_O_5_01 = {
+    id: "R-O-5-01",
+    category: "cross_object",
+    trigger: "Service.machine upgraded after Order creation (snapshot divergence)",
+    check: (ctx) => {
+        if (ctx.is_buy_operation) {
+            return {
+                id: "R-O-5-01",
+                level: "LOW",
+                category: "cross_object",
+                title: "Service snapshot mechanism — order.machine is a copy, not a reference",
+                description: "When service::buy() creates an Order, order.machine is COPIED from service.machine. Future Service.machine upgrades do NOT affect this Order. Same Service may have Orders running different Machine versions.",
+                affected_stakeholders: ["owner", "service_provider", "arbitrator"],
+                scenario: "Service provider upgrades Machine workflow — old Orders keep old workflow",
+                mitigation: "Track Machine version per Order (via order.machine address). Plan migration paths for legacy Orders. Document that old Orders are decoupled.",
+                evidence: "snapshot_mechanism",
+            };
+        }
+        return null;
+    },
+};
+const R_O_5_02 = {
+    id: "R-O-5-02",
+    category: "cross_object",
+    trigger: "Order references Progress that no longer exists or is corrupted",
+    check: (ctx) => {
+        if (ctx.progress_bound && ctx.object) {
+            return {
+                id: "R-O-5-02",
+                level: "MEDIUM",
+                category: "cross_object",
+                title: "Order-Progress 1:1 binding (E_PROGRESS_ALREADY_SPECIFIED)",
+                description: "Order.progress is one-time-set via on_progress (package-only). Cannot be rebound. If Progress object is corrupted, Order becomes stuck — cannot advance, cannot rebind.",
+                affected_stakeholders: ["owner", "agent"],
+                scenario: "Progress object becomes unresponsive or corrupted",
+                mitigation: "Ensure Progress integrity via Machine audit before publishing Service. Use arb_claim_compensation as escape hatch if Progress is stuck.",
+                evidence: `progress_bound=${ctx.progress_bound}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_5_03 = {
+    id: "R-O-5-03",
+    category: "cross_object",
+    trigger: "Order references Allocation that no longer exists or is corrupted",
+    check: (ctx) => {
+        if (ctx.object && ctx.progress_bound) {
+            return {
+                id: "R-O-5-03",
+                level: "MEDIUM",
+                category: "cross_object",
+                title: "Order-Allocation 1:1 binding (E_ALLOCATION_ALREADY_SPECIFIED)",
+                description: "Order.allocation is one-time-set via on_allocation (package-only). Cannot be rebound. If Allocation object is corrupted, fund distribution is blocked.",
+                affected_stakeholders: ["owner", "service_provider"],
+                scenario: "Allocation object has wrong allocator configuration",
+                mitigation: "Audit order_allocators configuration on Service BEFORE publishing. Use compensation_fund as fallback fund source.",
+                evidence: "allocation_binding",
+            };
+        }
+        return null;
+    },
+};
+const R_O_5_04 = {
+    id: "R-O-5-04",
+    category: "cross_object",
+    trigger: "Arbitration dispute appended to Order.dispute list",
+    check: (ctx) => {
+        if (ctx.operation === "arb_confirm") {
+            return {
+                id: "R-O-5-04",
+                level: "LOW",
+                category: "cross_object",
+                title: "Arb object will be appended to order.dispute (package-only dispute())",
+                description: "arb_confirm triggers Arb module to call order::dispute(arb_address), appending the Arb object to order.dispute list. Max 10 disputes (MAX_DISPUTE_COUNT). Frozen when claimed_by is set.",
+                affected_stakeholders: ["arbitrator", "owner", "agent"],
+                scenario: "Multiple arb_confirm calls create multiple Arb objects on same Order",
+                mitigation: "Track dispute count. Once at 10, no more disputes can be filed. Resolve existing disputes before filing new ones.",
+                evidence: `operation=arb_confirm, current_disputes=${ctx.current_dispute_count ?? 0}`,
+            };
+        }
+        return null;
+    },
+};
+const R_O_5_05 = {
+    id: "R-O-5-05",
+    category: "cross_object",
+    trigger: "External system expects OrderCompletedEvent (does not exist)",
+    check: (ctx) => {
+        if (ctx.is_buy_operation || ctx.object) {
+            return {
+                id: "R-O-5-05",
+                level: "MEDIUM",
+                category: "cross_object",
+                title: "Only NewOrderEvent emitted — no OrderCompletedEvent",
+                description: "Move contract ONLY emits NewOrderEvent at creation. Order completion/cancellation/refund are IMPLICIT — must be inferred by querying Progress.current_node (terminal? cancel?) or Order.claimed_by. External monitoring requires polling, not event-driven.",
+                affected_stakeholders: ["system"],
+                scenario: "Analytics dashboard expects OrderCompletedEvent to track completion rate",
+                mitigation: "Build composite query: NewOrderEvent + Order.progress query → infer completion. Document this limitation in monitoring tools. Long-term: advocate for Move upgrade to add OrderCompletedEvent.",
+                evidence: "no_order_completed_event",
+            };
+        }
+        return null;
+    },
+};
+const R_O_5_06 = {
+    id: "R-O-5-06",
+    category: "cross_object",
+    trigger: "service::buy pre-flight: Service not published or paused",
+    check: (ctx) => {
+        if (!ctx.is_buy_operation)
+            return null;
+        if (ctx.service_published === false) {
+            return {
+                id: "R-O-5-06",
+                level: "CRITICAL",
+                category: "cross_object",
+                title: "Service not published — service::buy will abort E_NOT_PUBLISHED",
+                description: "Cannot create Order from an unpublished Service. Service must be published (bPublished=true) before service::buy() can be called.",
+                affected_stakeholders: ["owner"],
+                scenario: "Buyer attempts to purchase from a draft Service",
+                mitigation: "Verify Service.bPublished=true before service::buy(). Service owner must call service::publish() first.",
+                evidence: `service_published=${ctx.service_published}`,
+            };
+        }
+        if (ctx.service_paused === true) {
+            return {
+                id: "R-O-5-06",
+                level: "CRITICAL",
+                category: "cross_object",
+                title: "Service paused — service::buy will abort E_PAUSED",
+                description: "Cannot create Order from a paused Service. Service must be unpaused before service::buy() can be called.",
+                affected_stakeholders: ["owner"],
+                scenario: "Buyer attempts to purchase from a paused Service (e.g. during maintenance)",
+                mitigation: "Wait for Service owner to call service::pause(false). Check Service.paused before service::buy().",
+                evidence: `service_paused=${ctx.service_paused}`,
+            };
+        }
+        return null;
+    },
+};
+const ALL_RULES = [
+    R_O_1_01, R_O_1_02, R_O_1_03, R_O_1_04, R_O_1_05,
+    R_O_2_01, R_O_2_02, R_O_2_03, R_O_2_04,
+    R_O_3_01, R_O_3_02, R_O_3_03, R_O_3_04,
+    R_O_4_01, R_O_4_02, R_O_4_03, R_O_4_04, R_O_4_05, R_O_4_06,
+    R_O_5_01, R_O_5_02, R_O_5_03, R_O_5_04, R_O_5_05, R_O_5_06,
+];
+export const ORDER_RISK_VERSION = "1.0.0";
+export function getAllOrderRiskRules() {
+    return [...ALL_RULES];
+}
+export function getOrderRiskRulesCount() {
+    return ALL_RULES.length;
+}
+export function getOrderRiskRulesByCategory(category) {
+    return ALL_RULES.filter(r => r.category === category);
+}
+export function getOrderRiskRuleById(id) {
+    return ALL_RULES.find(r => r.id === id);
+}
+export function assessOrderRisks(ctx) {
+    const risks = [];
+    for (const rule of ALL_RULES) {
+        const r = rule.check(ctx);
+        if (r)
+            risks.push(r);
+    }
+    const overall = risks.length === 0
+        ? "LOW"
+        : risks.some(r => r.level === "CRITICAL") ? "CRITICAL"
+            : risks.some(r => r.level === "HIGH") ? "HIGH"
+                : risks.some(r => r.level === "MEDIUM") ? "MEDIUM"
+                    : "LOW";
+    const byCategory = {};
+    for (const r of risks) {
+        byCategory[r.category] = (byCategory[r.category] ?? 0) + 1;
+    }
+    const advice = {};
+    for (const r of risks) {
+        for (const s of r.affected_stakeholders) {
+            if (!advice[s])
+                advice[s] = [];
+            advice[s].push(`${r.id}: ${r.mitigation}`);
+        }
+    }
+    let scene;
+    if (ctx.operation) {
+        const sceneMap = {
+            agent_set: "order_set_agent",
+            required_info_update: "order_required_info",
+            progress_advance: "order_advance",
+            arb_confirm: "order_arb_confirm",
+            arb_objection: "order_arb_objection",
+            arb_claim_compensation: "order_arb_claim_compensation",
+            receive: "order_receive",
+            transfer_to: "order_transfer",
+            service_buy: "order_create",
+        };
+        scene = findSceneById(sceneMap[ctx.operation] ?? "");
+    }
+    return {
+        summary: `Assessed ${risks.length} risk(s) across ${Object.keys(byCategory).length} categories`,
+        scene,
+        risks,
+        overall_risk: overall,
+        risks_by_category: byCategory,
+        stakeholder_advice: advice,
+        needs_human_review: risks.some(r => r.level === "CRITICAL" || r.level === "HIGH"),
+    };
+}
+export function checkPermissionLayer(operation, caller_is_owner, caller_is_agent) {
+    const l1_ops = ["receive", "transfer_to", "owner_change", "agent_set"];
+    const l2_ops = ["required_info_update", "progress_advance", "arb_confirm", "arb_objection", "arb_claim_compensation"];
+    const l3_ops = ["on_progress", "on_allocation", "dispute", "compensate"];
+    if (l3_ops.includes(operation)) {
+        return { allowed: false, layer: "L3_package_only", reason: "Package-only — not callable externally" };
+    }
+    if (l1_ops.includes(operation)) {
+        if (!caller_is_owner) {
+            return { allowed: false, layer: "L1_owner_only", reason: `Owner-only operation (${operation}) — agent or unauthorized caller` };
+        }
+        return { allowed: true, layer: "L1_owner_only" };
+    }
+    if (l2_ops.includes(operation)) {
+        if (!caller_is_owner && !caller_is_agent) {
+            return { allowed: false, layer: "L2_owner_or_agent", reason: `Requires owner or agent permission (${operation})` };
+        }
+        return { allowed: true, layer: "L2_owner_or_agent" };
+    }
+    return { allowed: false, layer: "L3_package_only", reason: `Unknown operation: ${operation}` };
+}