@wowok/agent-mcp 2.5.1 → 2.5.3

package/dist/knowledge/machine-ledger.js

@@ -3,22 +3,25 @@ export const MACHINE_SCENES = [
         id: "ecommerce_standard",
         name: "Standard E-commerce Flow",
         industry: ["ecommerce"],
-        scenario: "Order → Pay → Ship → Receive → Complete",
+        scenario: "Paid (entry) → Ship → Receive → Complete",
         participants: [
-            { role: "customer", permission_type: "OrderHolder", involved_in: ["Order", "Receive"] },
+            { role: "customer", permission_type: "OrderHolder", involved_in: ["Receive"] },
             { role: "merchant", permission_type: "Permission", involved_in: ["Ship"] },
         ],
         recommended_patterns: ["P-M-SEQ"],
         recommended_topology: ["P-M-LINEAR"],
         guard_requirements: [
-            { forward: "Ship", scene: "machine_forward_guard", purpose: "Verify payment completion" },
+            { forward: "Ship", scene: "machine_forward_guard", purpose: "Verify order is paid (post-buy state)" },
             { forward: "Receive", scene: "machine_forward_guard", purpose: "Verify identity" },
         ],
         allocation_integration: "Complete node -> Allocator distributes funds to merchant",
         special_constraints: [
-            "Payment must complete before shipping (Guard verifies order.amount is paid)",
+            "First node 'Paid' represents post-payment state — buy() completes payment atomically before Progress is created",
+            "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
+            "All nodes after entry represent order processing (ship, receive, complete), NOT payment actions",
             "Receipt auto-triggers fund allocation",
         ],
+        first_node_semantics: "Paid — order has been created and paid via Service.buy(); Machine starts at post-payment state",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M2", "M3", "M5", "M8"],
     },
@@ -26,9 +29,9 @@ export const MACHINE_SCENES = [
         id: "ecommerce_with_exceptions",
         name: "E-commerce Flow with Exception Branches",
         industry: ["ecommerce"],
-        scenario: "Order → Pay → Ship → {Receive → Complete | Lost → Arbitration | Return → Refund}",
+        scenario: "Paid (entry) → Ship → {Receive → Complete | Lost → Arbitration | Return → Refund}",
         participants: [
-            { role: "customer", permission_type: "OrderHolder", involved_in: ["Order", "Receive", "Return"] },
+            { role: "customer", permission_type: "OrderHolder", involved_in: ["Receive", "Return"] },
             { role: "merchant", permission_type: "Permission", involved_in: ["Ship", "Refund"] },
             { role: "arbitrator", permission_type: "NamedOperator", involved_in: ["Arbitration"] },
         ],
@@ -40,10 +43,13 @@ export const MACHINE_SCENES = [
         ],
         allocation_integration: "Complete->merchant | Refund->customer | Arb->arbitrator",
         special_constraints: [
+            "First node 'Paid' represents post-payment state — buy() completes payment atomically before Progress is created",
+            "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
             "Lost node threshold=2 (customer + merchant dual-sig)",
             "Competing Pair: Receive vs Lost (first-wins)",
             "Arbitration flow independent of main flow",
         ],
+        first_node_semantics: "Paid — order has been created and paid via Service.buy(); Machine starts at post-payment state",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M2", "M3", "M5", "M6", "M8"],
     },
@@ -51,22 +57,25 @@ export const MACHINE_SCENES = [
         id: "rental_standard",
         name: "Equipment Rental Flow",
         industry: ["rental"],
-        scenario: "Reserve → Pay Deposit → Pickup → In Use → Return → Refund Deposit",
+        scenario: "DepositPaid (entry) → Pickup → In Use → Return → Refund Deposit",
         participants: [
-            { role: "customer", permission_type: "OrderHolder", involved_in: ["Reserve", "Pickup", "Return"] },
+            { role: "customer", permission_type: "OrderHolder", involved_in: ["Pickup", "Return"] },
             { role: "merchant", permission_type: "Permission", involved_in: ["Deliver", "Refund Deposit"] },
         ],
         recommended_patterns: ["P-M-SEQ"],
         recommended_topology: ["P-M-LINEAR"],
         guard_requirements: [
-            { forward: "Pickup", scene: "machine_forward_guard", purpose: "Verify deposit paid" },
+            { forward: "Pickup", scene: "machine_forward_guard", purpose: "Verify deposit paid (post-buy state)" },
             { forward: "Return", scene: "machine_forward_guard", purpose: "Verify equipment condition" },
         ],
         allocation_integration: "Return complete -> deposit refund + rental fee allocation",
         special_constraints: [
+            "First node 'DepositPaid' represents post-payment state — buy() completes deposit payment atomically before Progress is created",
+            "No separate 'Reserve' or 'PayDeposit' nodes needed — reservation and payment are handled by Service.buy(), not Machine",
             "Deposit and rental fee separated (two Allocators)",
             "Equipment damage verified by Guard (retained_submission stores inspection report)",
         ],
+        first_node_semantics: "DepositPaid — deposit has been paid via Service.buy(); Machine starts at post-deposit state",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M2", "M3", "M5", "M8"],
     },
@@ -90,6 +99,7 @@ export const MACHINE_SCENES = [
             "Customer Forward: namedOperator='' (OrderHolder)",
             "Merchant Forward: permissionIndex=2",
         ],
+        first_node_semantics: "Initiated — order has been created and paid via Service.buy(); Machine starts at post-payment state, awaiting dual-sig confirmation",
         mutable_after_publish: false,
         m_rounds_focus: ["M3", "M4", "M5"],
     },
@@ -113,6 +123,7 @@ export const MACHINE_SCENES = [
             "GuardIdentifier must be numeric type (extracts weight)",
             "Prevent double-voting (Guard queries arb.voted has)",
         ],
+        first_node_semantics: "VoteOpened — dispute has been submitted (order already paid via Service.buy()); Machine starts at post-payment dispute state",
         mutable_after_publish: false,
         m_rounds_focus: ["M3", "M4", "M5"],
     },
@@ -138,7 +149,9 @@ export const MACHINE_SCENES = [
             "Cross-Machine dependency is one-way (no cycles)",
             "Each Machine must be published independently",
             "Dependency verification: indirect via progress::new -> assert_published (see 06 §14.6)",
+            "Each Machine in the chain starts at a post-payment state (each link's Service.buy() handles payment independently)",
         ],
+        first_node_semantics: "UpstreamVerified — order has been paid via upstream Service.buy(); Machine starts at post-payment state, verifying upstream completion",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M3", "M8"],
     },
@@ -163,7 +176,9 @@ export const MACHINE_SCENES = [
             "Proof MUST be generated by messenger.submitChainProof",
             "submitChainProof about_address = peerAddress (NOT sessionId)",
             "Guard table item name <64 BCS bytes (MAX_NAME_LENGTH=64)",
+            "First node represents post-payment state — payment is handled by Service.buy(), not Machine",
         ],
+        first_node_semantics: "Paid — order has been created and paid via Service.buy(); Machine starts at post-payment state, awaiting proof submission",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M3", "M7"],
     },
@@ -187,6 +202,7 @@ export const MACHINE_SCENES = [
             "Uses query_reward_record_count == 0 for anti-reentry",
             "Reward object must be already created",
         ],
+        first_node_semantics: "Eligible — order has been created and paid via Service.buy(); Machine starts at post-payment state, customer is eligible to claim reward",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M3", "M8"],
     },
@@ -213,6 +229,7 @@ export const MACHINE_SCENES = [
             "Prevent double-vote (R-X1-14 CRITICAL)",
             "MAX_DISPUTE_COUNT=10 per order",
         ],
+        first_node_semantics: "DisputeOpened — order has been created and paid via Service.buy(); Machine starts at post-payment dispute state",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M3", "M4", "M5", "M8"],
     },
@@ -220,9 +237,9 @@ export const MACHINE_SCENES = [
         id: "subscription",
         name: "Subscription / Membership Flow",
         industry: ["subscription", "service"],
-        scenario: "Subscribe → Pay → Activate → [Renew | Expire] → Cancel/End",
+        scenario: "Paid (entry) → Activate → [Renew | Expire] → Cancel/End",
         participants: [
-            { role: "subscriber", permission_type: "OrderHolder", involved_in: ["Subscribe", "Renew", "Cancel"] },
+            { role: "subscriber", permission_type: "OrderHolder", involved_in: ["Renew", "Cancel"] },
             { role: "provider", permission_type: "Permission", involved_in: ["Activate", "Pause"] },
         ],
         recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
@@ -233,11 +250,14 @@ export const MACHINE_SCENES = [
         ],
         allocation_integration: "Renew -> fund allocation | Expire -> stop service",
         special_constraints: [
+            "First node 'Paid' represents post-payment state — buy() completes subscription payment atomically before Progress is created",
+            "No separate 'Subscribe' or 'Pay' nodes needed — subscription and payment are handled by Service.buy(), not Machine",
             "Time-lock: context(Clock) >= progress.entry_time + duration",
             "Competing Pair: Renew vs Expire (first-wins)",
             "Repository records subscription status",
             "Note: Machine.consensus_repositories is declarative-only and NOT auto-passed to Progress (see 06 §14.4)",
         ],
+        first_node_semantics: "Paid — subscription has been created and paid via Service.buy(); Machine starts at post-payment state, awaiting activation",
         mutable_after_publish: false,
         m_rounds_focus: ["M1", "M3", "M6", "M8"],
     },

package/dist/knowledge/machine-templates.js

@@ -4,7 +4,8 @@ export const MACHINE_TEMPLATES = [
         id: "tpl_machine_ecommerce_standard",
         scene_id: "ecommerce_standard",
         name: "Standard E-commerce Flow",
-        description: "Linear e-commerce workflow: Order -> Pay -> Ship -> Receive -> Complete. " +
+        description: "Linear e-commerce workflow: Paid (entry) -> Ship -> Receive -> Complete. " +
+            "Payment is handled by Service.buy() atomically; Machine starts at post-payment state. " +
             "Funds auto-allocated to merchant at Complete node. Recommended baseline for new merchants.",
         recommended_patterns: ["P-M-SEQ"],
         recommended_topology: ["P-M-LINEAR"],
@@ -31,13 +32,6 @@ export const MACHINE_TEMPLATES = [
                 default: "Receive",
                 description: "Forward name for customer receipt confirmation",
             },
-            {
-                name: "pay_guard_name",
-                type: "guard_ref",
-                required: true,
-                description: "Guard name verifying payment completion on Ship forward",
-                constraint: "Must be CREATE-only Guard; use tpl_buy_guard_whitelist pattern",
-            },
             {
                 name: "complete_node_name",
                 type: "string",
@@ -47,8 +41,7 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         example_nodes: [
-            { name: "OrderCreated", description: "Order placed, awaiting payment" },
-            { name: "Paid", description: "Payment confirmed, awaiting shipment" },
+            { name: "Paid", description: "Entry: order created and paid via Service.buy(); Machine starts here" },
             { name: "Shipped", description: "Goods dispatched" },
             { name: "Received", description: "Customer confirmed receipt" },
             { name: "${complete_node_name}", description: "Terminal: triggers allocation" },
@@ -56,24 +49,10 @@ export const MACHINE_TEMPLATES = [
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "OrderCreated",
-                threshold: 1,
-                forwards: [
-                    { name: "Enter", weight: 1, named_operator: "", permission_index: 0 },
-                ],
-            },
-            {
-                prev_node: "OrderCreated",
                 next_node: "Paid",
                 threshold: 1,
                 forwards: [
-                    {
-                        name: "Pay",
-                        weight: 1,
-                        named_operator: "",
-                        permission_index: 0,
-                        guard: "${pay_guard_name}",
-                    },
+                    { name: "Enter", weight: 1, named_operator: "", permission_index: 0 },
                 ],
             },
             {
@@ -106,13 +85,7 @@ export const MACHINE_TEMPLATES = [
                 ],
             },
         ],
-        required_guards: [
-            {
-                guard_template_id: "tpl_buy_guard_whitelist",
-                bound_to_forward: "Pay",
-                purpose: "Verify payment completion",
-            },
-        ],
+        required_guards: [],
         required_permissions: [
             { index: 2, name: "merchant", description: "Merchant role for Ship + Finish" },
             { index: 3, name: "admin", description: "Admin override (optional)" },
@@ -129,16 +102,16 @@ export const MACHINE_TEMPLATES = [
         relevant_risks: ["R-M1-01", "R-M1-02", "R-M1-08", "R-M2-01", "R-M3-02", "R-M4-01"],
         creation_notes: [
             "Build order: Permission -> Machine (unpublished) -> Guards -> Bind guards -> Publish -> Bind to Service",
-            "Pay forward's Guard must verify order.amount is fully paid — use query 1563 (order.service) cross-check",
-            "Entry point: prev_node='' (empty string) — at least one Pair must exist with empty prev_node",
+            "First node 'Paid' represents post-payment state — Service.buy() completes payment atomically before Progress is created",
+            "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
+            "Entry point: prev_node='' (empty string) targets 'Paid' — at least one Pair must exist with empty prev_node",
             "If using P16 circular reference for Service, use name not address (Service not yet published)",
         ],
         example_use_case: "Small e-commerce shop selling camera accessories. Linear flow with no exceptions. " +
             "Funds allocated to merchant personal address on Complete.",
         publish_checklist: [
-            "All 5 nodes have at least one outgoing Forward (except terminal)",
-            "Entry Pair exists (prev_node='')",
-            "Pay forward Guard created and tested via gen_passport",
+            "All 4 nodes have at least one outgoing Forward (except terminal)",
+            "Entry Pair exists (prev_node='' targets 'Paid')",
             "permissionIndex values match Permission object indices",
             "Test Progress run on testnet",
             "machineNode2file export as backup",
@@ -148,7 +121,8 @@ export const MACHINE_TEMPLATES = [
         id: "tpl_machine_ecommerce_exceptions",
         scene_id: "ecommerce_with_exceptions",
         name: "E-commerce Flow with Exception Branches",
-        description: "Multi-path workflow: Pay -> Ship -> Receive/Lost/Return. Lost uses dual-sig (threshold=2). " +
+        description: "Multi-path workflow: Paid (entry) -> Ship -> Receive/Lost/Return. Lost uses dual-sig (threshold=2). " +
+            "Payment is handled by Service.buy() atomically; Machine starts at post-payment state. " +
             "Return path opens Refund -> Complete. Competing pairs first-wins.",
         recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
         recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
@@ -190,8 +164,7 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         example_nodes: [
-            { name: "OrderCreated" },
-            { name: "Paid" },
+            { name: "Paid", description: "Entry: order created and paid via Service.buy(); Machine starts here" },
             { name: "Shipped" },
             { name: "Received" },
             { name: "Lost" },
@@ -202,15 +175,9 @@ export const MACHINE_TEMPLATES = [
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "OrderCreated",
-                threshold: 1,
-                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
-            },
-            {
-                prev_node: "OrderCreated",
                 next_node: "Paid",
                 threshold: 1,
-                forwards: [{ name: "Pay", weight: 1, named_operator: "" }],
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
             },
             {
                 prev_node: "Paid",
@@ -267,11 +234,6 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         required_guards: [
-            {
-                guard_template_id: "tpl_forward_node_check",
-                bound_to_forward: "Pay",
-                purpose: "Verify payment completion",
-            },
             {
                 guard_template_id: "tpl_forward_node_check",
                 bound_to_forward: "MerchantConfirm",
@@ -311,6 +273,8 @@ export const MACHINE_TEMPLATES = [
             "R-M3-02", "R-M3-04", "R-M3-05", "R-M4-01", "R-M5-03",
         ],
         creation_notes: [
+            "First node 'Paid' represents post-payment state — Service.buy() completes payment atomically before Progress is created",
+            "No separate 'Order' or 'Pay' nodes needed — payment is handled by Service.buy(), not Machine",
             "Competing Pairs (Shipped -> Received/Lost/Return) are mutually exclusive — first threshold met wins",
             "Lost node threshold=2 means BOTH customer and merchant Forwards must execute",
             "TimeGuard must use context(Clock) >= progress.entry_time + duration",
@@ -331,7 +295,8 @@ export const MACHINE_TEMPLATES = [
         id: "tpl_machine_rental",
         scene_id: "rental_standard",
         name: "Equipment Rental Flow",
-        description: "Rental flow: Reserve -> Pay Deposit -> Pickup -> In Use -> Return -> Refund Deposit. " +
+        description: "Rental flow: DepositPaid (entry) -> Pickup -> In Use -> Return -> Refund Deposit. " +
+            "Payment is handled by Service.buy() atomically; Machine starts at post-deposit state. " +
             "Separates deposit from rental fee (two Allocators). Damage report via retained_submission.",
         recommended_patterns: ["P-M-SEQ"],
         recommended_topology: ["P-M-LINEAR"],
@@ -360,8 +325,7 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         example_nodes: [
-            { name: "Reserved" },
-            { name: "DepositPaid" },
+            { name: "DepositPaid", description: "Entry: deposit paid via Service.buy(); Machine starts here" },
             { name: "PickedUp" },
             { name: "InUse" },
             { name: "Return" },
@@ -372,17 +336,9 @@ export const MACHINE_TEMPLATES = [
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "Reserved",
-                threshold: 1,
-                forwards: [{ name: "Reserve", weight: 1, named_operator: "" }],
-            },
-            {
-                prev_node: "Reserved",
                 next_node: "DepositPaid",
                 threshold: 1,
-                forwards: [
-                    { name: "PayDeposit", weight: 1, named_operator: "", guard: "deposit_guard" },
-                ],
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
             },
             {
                 prev_node: "DepositPaid",
@@ -435,11 +391,6 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         required_guards: [
-            {
-                guard_template_id: "tpl_allocator_threshold",
-                bound_to_forward: "PayDeposit",
-                purpose: "Verify deposit amount >= required amount",
-            },
             {
                 guard_template_id: "tpl_forward_privacy_delivery_proof",
                 bound_to_forward: "Inspect",
@@ -473,9 +424,10 @@ export const MACHINE_TEMPLATES = [
             "R-M4-01", "R-M5-02",
         ],
         creation_notes: [
+            "First node 'DepositPaid' represents post-payment state — Service.buy() completes deposit payment atomically before Progress is created",
+            "No separate 'Reserve' or 'PayDeposit' nodes needed — reservation and payment are handled by Service.buy(), not Machine",
             "Damage report uses retained_submission — values stored uniquely by (current_node, next_node, forward_name)",
             "Two competing Pairs at Return node: DamageCheck vs Complete (clean return)",
-            "Deposit Guard must verify amount via order.amount query, not hardcoded value",
             "DamageDeduction Allocation uses sharing.who=Entity (merchant), not OrderHolder",
         ],
         example_use_case: "Camera equipment rental: customer pays 1000 WOW deposit, returns equipment, " +
@@ -860,7 +812,7 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         example_nodes: [
-            { name: "OrderCreated" },
+            { name: "Paid", description: "Entry: order created and paid via Service.buy(); Machine starts here" },
             { name: "${proof_node_name}", description: "Customer submits Proof via Messenger" },
             { name: "${delivery_node_name}" },
             { name: "Complete" },
@@ -868,12 +820,12 @@ export const MACHINE_TEMPLATES = [
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "OrderCreated",
+                next_node: "Paid",
                 threshold: 1,
                 forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
             },
             {
-                prev_node: "OrderCreated",
+                prev_node: "Paid",
                 next_node: "${proof_node_name}",
                 threshold: 1,
                 forwards: [
@@ -1204,7 +1156,7 @@ export const MACHINE_TEMPLATES = [
             },
         ],
         example_nodes: [
-            { name: "Subscribed" },
+            { name: "Paid", description: "Entry: subscription created and paid via Service.buy(); Machine starts here" },
             { name: "Active" },
             { name: "RenewEligible" },
             { name: "Renewed" },
@@ -1215,12 +1167,12 @@ export const MACHINE_TEMPLATES = [
         example_pairs: [
             {
                 prev_node: "",
-                next_node: "Subscribed",
+                next_node: "Paid",
                 threshold: 1,
-                forwards: [{ name: "Subscribe", weight: 1, named_operator: "" }],
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
             },
             {
-                prev_node: "Subscribed",
+                prev_node: "Paid",
                 next_node: "Active",
                 threshold: 1,
                 forwards: [
@@ -1324,6 +1276,8 @@ export const MACHINE_TEMPLATES = [
             "R-M3-02", "R-M3-04", "R-M4-01", "R-M5-04",
         ],
         creation_notes: [
+            "First node 'Paid' represents post-payment state — Service.buy() completes subscription payment atomically before Progress is created",
+            "No separate 'Subscribe' or 'Pay' nodes needed — subscription and payment are handled by Service.buy(), not Machine",
             "Time-lock uses context(Clock) — verify Clock address in Guard table",
             "Competing Pair: Renew vs Expire vs Cancel — first-wins",
             "Renewed node loops back to Active (recurring subscription)",
@@ -1337,7 +1291,7 @@ export const MACHINE_TEMPLATES = [
             "Time-lock Guards tested on testnet (both TimeUnlock + AutoExpire)",
             "Competing Pair semantics verified (Renew vs Expire vs Cancel)",
             "Repository write tested (subscription status queryable)",
-            "Renewal loop tested: Subscribed -> Active -> RenewEligible -> Renewed -> Active",
+            "Renewal loop tested: Paid -> Active -> RenewEligible -> Renewed -> Active",
         ],
     },
 ];

package/dist/knowledge/mcp-schema-audit.js

@@ -484,7 +484,7 @@ export function analyzeHandlerTypeSafety(instances) {
 export function analyzeOutputSchemaCoverage(census) {
     const findings = [];
     for (const c of census) {
-        if (!c.layer3_generated.output_exists) {
+        if (!c.layer3_generated.output_exists && c.name !== "onchain_operations") {
             findings.push({
                 rule_id: 'MCP-OUTPUT-001',
                 severity: 'high',
@@ -559,7 +559,7 @@ export function analyzeSchemaQueryReflection(census) {
                 fix: `Run pnpm generate:schemas.`,
             });
         }
-        if (!c.layer3_generated.output_exists) {
+        if (!c.layer3_generated.output_exists && c.name !== "onchain_operations") {
             findings.push({
                 rule_id: 'MCP-REFLECT-002',
                 severity: 'medium',
@@ -574,6 +574,7 @@ export function analyzeSchemaQueryReflection(census) {
         'permission', 'service', 'machine', 'progress', 'guard',
         'arbitration', 'repository', 'contact', 'treasury', 'reward',
         'allocation', 'personal', 'payment', 'demand', 'order', 'gen_passport',
+        'proof', 'gen_proof',
     ];
     for (const op of onchainOps) {
         const opFile = path.join(GENERATED_SCHEMAS_DIR, `onchain_operations_${op}.schema.json`);

package/dist/knowledge/overrides-loader.d.ts

@@ -0,0 +1,13 @@
+import type { OverrideCategory } from "../loop-engineering/improve.js";
+export interface OverrideConfig {
+    "risk-thresholds"?: Record<string, unknown>;
+    "descriptions"?: Record<string, unknown>;
+    "industry-profiles"?: Record<string, unknown>;
+    "scenario-defaults"?: Record<string, unknown>;
+    "recovery-priorities"?: Record<string, unknown>;
+}
+export declare function loadOverrides(forceReload?: boolean): OverrideConfig;
+export declare function getOverride(category: OverrideCategory): Record<string, unknown> | undefined;
+export declare function clearOverrideCache(): void;
+export declare function listOverrideFiles(): string[];
+export declare function getOverridesDirPath(): string;

package/dist/knowledge/overrides-loader.js

@@ -0,0 +1,67 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function wowokRootDir() {
+    return process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+}
+function overridesDir() {
+    return join(wowokRootDir(), "overrides");
+}
+let overrideCache;
+export function loadOverrides(forceReload = false) {
+    if (overrideCache && !forceReload)
+        return overrideCache;
+    const config = {};
+    const dir = overridesDir();
+    if (!existsSync(dir)) {
+        overrideCache = config;
+        return config;
+    }
+    const categories = [
+        "risk-thresholds",
+        "descriptions",
+        "industry-profiles",
+        "scenario-defaults",
+        "recovery-priorities",
+    ];
+    for (const cat of categories) {
+        const filePath = join(dir, `${cat}.json`);
+        if (!existsSync(filePath))
+            continue;
+        try {
+            const raw = readFileSync(filePath, "utf-8");
+            const parsed = JSON.parse(raw);
+            const { _last_applied_proposal, _last_applied_at, ...userFields } = parsed;
+            void _last_applied_proposal;
+            void _last_applied_at;
+            config[cat] = userFields;
+        }
+        catch {
+        }
+    }
+    overrideCache = config;
+    return config;
+}
+export function getOverride(category) {
+    const config = loadOverrides();
+    return config[category];
+}
+export function clearOverrideCache() {
+    overrideCache = undefined;
+}
+export function listOverrideFiles() {
+    const dir = overridesDir();
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+}
+export function getOverridesDirPath() {
+    return overridesDir();
+}

package/dist/knowledge/payment-risk.d.ts

@@ -23,6 +23,10 @@ export interface PaymentRiskCheckContext {
     uses_signer_for_provenance?: boolean;
     coin_field_lint_reviewed?: boolean;
     constants_synced?: boolean;
+    uses_scene_binding?: boolean;
+    has_for_object?: boolean;
+    has_for_guard?: boolean;
+    has_index?: boolean;
 }
 export declare const PAYMENT_RISK_RULES: {
     rule: PaymentRisk;

package/dist/knowledge/payment-risk.js

@@ -155,6 +155,71 @@ const R_P_07 = {
         return { ...R_P_07.rule, evidence: "uses_signer_for_provenance=true (informational only)" };
     },
 };
+const R_P_08 = {
+    rule: {
+        id: "R-PAYMENT-08",
+        level: "MEDIUM",
+        category: "semantic",
+        title: "Payment scene binding (for_object + for_guard + index) — anti-reuse for exception branches",
+        description: "PaymentInfo supports for_object (binds to specific Order), for_guard (binds to specific Guard), " +
+            "and index (binds to specific Progress step) — payment.move#L66-71. When all three are set via " +
+            "payment_info_with_guard (payment.move#L82-86), the Payment is scene-bound: it can ONLY be used " +
+            "in the specific order + guard + progress context. This is the anti-reuse design for exception " +
+            "branch compensation (e.g., delivery delay >30min triggers auto-compensation). " +
+            "Payment is immutable (freeze_object, payment.move#L160) — binding cannot be altered. " +
+            "VERIFIER-EVIDENCE DESIGN: customer submits Payment, Guard verifies binding fields match current context.",
+        affected_stakeholders: ["signer", "recipient", "consumer"],
+        scenario: "Treasury creates compensation Payment with PaymentInfo(for_object=order, for_guard=exception_guard, index=current_progress) for delivery delay",
+        mitigation: "Use payment_info_with_guard for all exception branch Payments. Ensure for_object, for_guard, and index " +
+            "all match the intended context. Use tpl_payment_exception_compensation (guard-templates.ts) as design template.",
+        auto_fixable: false,
+    },
+    check: (ctx) => {
+        if (!ctx.uses_scene_binding)
+            return null;
+        const missing = [];
+        if (!ctx.has_for_object)
+            missing.push("for_object not set (Order binding missing)");
+        if (!ctx.has_for_guard)
+            missing.push("for_guard not set (Guard binding missing)");
+        if (!ctx.has_index)
+            missing.push("index not set (Progress step binding missing)");
+        if (missing.length === 0)
+            return null;
+        return { ...R_P_08.rule, evidence: `incomplete scene binding: ${missing.join(", ")}` };
+    },
+};
+const R_P_09 = {
+    rule: {
+        id: "R-PAYMENT-09",
+        level: "LOW",
+        category: "semantic",
+        title: "PaymentInfo variant selection — use payment_info_with_guard for exception branches",
+        description: "PaymentInfo has 4 constructor variants (payment.move#L66-86): " +
+            "payment_info (for_object+remark+index, no for_guard), " +
+            "payment_info2 (remark+index, no for_object/for_guard), " +
+            "payment_info_with_guard (for_object+for_guard+remark+index — FULL binding), " +
+            "payment_info2_with_guard (for_guard+remark+index, no for_object). " +
+            "For exception branch compensation, ALWAYS use payment_info_with_guard to get full scene binding. " +
+            "Using payment_info (without for_guard) or payment_info2 (without for_object) weakens anti-reuse protection.",
+        affected_stakeholders: ["signer", "consumer"],
+        scenario: "Caller uses payment_info instead of payment_info_with_guard for exception compensation; for_guard is lost",
+        mitigation: "For exception branch Payments: always use payment_info_with_guard(for_object, for_guard, remark, index). " +
+            "For simple Payments without scene binding: payment_info or payment_info2 is fine. " +
+            "SDK should auto-select the variant based on which fields are provided.",
+        auto_fixable: true,
+    },
+    check: (ctx) => {
+        if (!ctx.uses_scene_binding)
+            return null;
+        if (ctx.payment_info_variant === "payment_info_with_guard")
+            return null;
+        return {
+            ...R_P_09.rule,
+            evidence: `uses_scene_binding=true but variant=${ctx.payment_info_variant ?? "unknown"} (should be payment_info_with_guard)`,
+        };
+    },
+};
 export const PAYMENT_RISK_RULES = [
     R_P_01,
     R_P_02,
@@ -163,6 +228,8 @@ export const PAYMENT_RISK_RULES = [
     R_P_05,
     R_P_06,
     R_P_07,
+    R_P_08,
+    R_P_09,
 ];
 export const PAYMENT_RISK_VERSION = "1.0.0";
 export function checkPaymentRisks(ctx) {

package/dist/knowledge/repository-confirm.d.ts

@@ -25,6 +25,10 @@ export interface RepositoryOpCheckInput {
     reward_count?: number;
     is_data_remove_with_passport?: boolean;
     description?: string;
+    has_quote_guard?: boolean;
+    quote_guard_is_depended?: boolean;
+    quote_guard_verifies_payment?: boolean;
+    has_owner_receive?: boolean;
 }
 export declare function preCheckRepositoryOp(input: RepositoryOpCheckInput): RepositoryConfirmItem[];
 export declare function canProceedRepositoryOp(input: RepositoryOpCheckInput): {