@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/service-risk.js

@@ -0,0 +1,615 @@
+import { MAX_SALE_COUNT, MAX_REPOSITORY_COUNT, MAX_ARBITRATION_COUNT, MAX_DISCOUNT_TOTAL_COUNT, MAX_WIP_LENGTH, MAX_WIP_HASH_LENGTH, } from "@wowok/wowok";
+const R_S_1_01 = {
+    id: "R-S-1-01",
+    category: "structural",
+    trigger: "sales count exceeds MAX_SALE_COUNT (50)",
+    check: (ctx) => {
+        const count = ctx.current_sales_count ?? 0;
+        if (ctx.sales && (ctx.sales.op === "add" || ctx.sales.op === "set")) {
+            const newCount = ctx.sales.op === "set" ? ctx.sales.sales.length : count + ctx.sales.sales.length;
+            if (newCount > MAX_SALE_COUNT) {
+                return {
+                    id: "R-S-1-01",
+                    level: "HIGH",
+                    category: "structural",
+                    title: "Sales count exceeds limit",
+                    description: `Service would have ${newCount} sales items, exceeds MAX_SALE_COUNT ${MAX_SALE_COUNT}`,
+                    affected_stakeholders: ["owner", "system"],
+                    scenario: "Adding too many product SKUs",
+                    mitigation: "Split into multiple Service objects or remove discontinued items",
+                    evidence: `sales_count=${newCount}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_S_1_02 = {
+    id: "R-S-1-02",
+    category: "structural",
+    trigger: "repositories count exceeds MAX_REPOSITORY_COUNT (100)",
+    check: (ctx) => {
+        const count = ctx.current_repositories_count ?? 0;
+        if (ctx.repositories && (ctx.repositories.op === "add" || ctx.repositories.op === "set")) {
+            const newCount = ctx.repositories.op === "set" ? ctx.repositories.objects.length : count + ctx.repositories.objects.length;
+            if (newCount > MAX_REPOSITORY_COUNT) {
+                return {
+                    id: "R-S-1-02",
+                    level: "MEDIUM",
+                    category: "structural",
+                    title: "Repositories count exceeds limit",
+                    description: `Service would have ${newCount} repositories, exceeds MAX_REPOSITORY_COUNT ${MAX_REPOSITORY_COUNT}`,
+                    affected_stakeholders: ["owner"],
+                    scenario: "Binding too many data repositories",
+                    mitigation: "Consolidate repositories or remove inactive ones",
+                    evidence: `repositories_count=${newCount}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_S_1_03 = {
+    id: "R-S-1-03",
+    category: "structural",
+    trigger: "arbitrations count exceeds MAX_ARBITRATION_COUNT (20)",
+    check: (ctx) => {
+        const count = ctx.current_arbitrations_count ?? 0;
+        if (ctx.arbitrations && (ctx.arbitrations.op === "add" || ctx.arbitrations.op === "set")) {
+            const newCount = ctx.arbitrations.op === "set" ? ctx.arbitrations.objects.length : count + ctx.arbitrations.objects.length;
+            if (newCount > MAX_ARBITRATION_COUNT) {
+                return {
+                    id: "R-S-1-03",
+                    level: "HIGH",
+                    category: "structural",
+                    title: "Arbitrations count exceeds limit",
+                    description: `Service would have ${newCount} arbitrations, exceeds MAX_ARBITRATION_COUNT ${MAX_ARBITRATION_COUNT}`,
+                    affected_stakeholders: ["owner", "arbitrator"],
+                    scenario: "Binding too many Arbitration objects",
+                    mitigation: "Use 1-3 Arbitration objects covering different dispute scopes",
+                    evidence: `arbitrations_count=${newCount}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_S_1_04 = {
+    id: "R-S-1-04",
+    category: "structural",
+    trigger: "WIP hash length exceeds MAX_WIP_HASH_LENGTH (64) or URL exceeds MAX_WIP_LENGTH (1024)",
+    check: (ctx) => {
+        if (ctx.sales && (ctx.sales.op === "add" || ctx.sales.op === "set")) {
+            for (const s of ctx.sales.sales) {
+                if (s.wip_hash && s.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+                    return {
+                        id: "R-S-1-04",
+                        level: "HIGH",
+                        category: "structural",
+                        title: "WIP hash length exceeds limit",
+                        description: `Sale "${s.name}" wip_hash length ${s.wip_hash.length} > MAX_WIP_HASH_LENGTH ${MAX_WIP_HASH_LENGTH}`,
+                        affected_stakeholders: ["owner", "customer"],
+                        scenario: "Malformed WIP hash (should be sha256 hex, 64 chars)",
+                        mitigation: "Use sha256 hex hash (64 characters, no prefix)",
+                        evidence: `wip_hash_length=${s.wip_hash.length}`,
+                    };
+                }
+                if (s.wip && s.wip.length > MAX_WIP_LENGTH) {
+                    return {
+                        id: "R-S-1-04",
+                        level: "HIGH",
+                        category: "structural",
+                        title: "WIP URL length exceeds limit",
+                        description: `Sale "${s.name}" wip URL length ${s.wip.length} > MAX_WIP_LENGTH ${MAX_WIP_LENGTH}`,
+                        affected_stakeholders: ["owner"],
+                        scenario: "WIP URL too long (use IPFS or short HTTPS URL)",
+                        mitigation: "Use IPFS CID or shorter URL",
+                        evidence: `wip_url_length=${s.wip.length}`,
+                    };
+                }
+            }
+        }
+        return null;
+    },
+};
+const R_S_1_05 = {
+    id: "R-S-1-05",
+    category: "structural",
+    trigger: "Permission index not in Service range (300-320) used on Service object",
+    check: (ctx) => {
+        if (ctx.target_objects_types?.includes("Service")) {
+        }
+        return null;
+    },
+};
+const R_S_2_01 = {
+    id: "R-S-2-01",
+    category: "semantic",
+    trigger: "WIP hash tampering risk — owner updates WIP file without updating wip_hash",
+    check: (ctx) => {
+        if (ctx.sales && (ctx.sales.op === "add" || ctx.sales.op === "set")) {
+            for (const s of ctx.sales.sales) {
+                if (s.wip && !s.wip_hash) {
+                    return {
+                        id: "R-S-2-01",
+                        level: "CRITICAL",
+                        category: "semantic",
+                        title: "WIP hash missing — tampering risk",
+                        description: `Sale "${s.name}" has wip URL but no wip_hash. Owner could replace the WIP file without customers noticing.`,
+                        affected_stakeholders: ["customer", "owner"],
+                        scenario: "Owner sets wip without hash, then changes file content later",
+                        mitigation: "Always compute sha256(wip_file_content) and set as wip_hash. SDK auto-derives if omitted, but explicit hash is safer.",
+                        evidence: `sale=${s.name}`,
+                    };
+                }
+            }
+        }
+        return null;
+    },
+};
+const R_S_2_02 = {
+    id: "R-S-2-02",
+    category: "semantic",
+    trigger: "compensation_fund confused with Service balance (internal Balance<T>)",
+    check: (ctx) => {
+        if (ctx.compensation_fund_add) {
+            return {
+                id: "R-S-2-02",
+                level: "HIGH",
+                category: "semantic",
+                title: "compensation_fund is internal Balance<T>, NOT Service-owned Treasury",
+                description: `Depositing ${ctx.compensation_fund_add.balance} to compensation_fund. This balance is internal to Service<T> and is consumed by arbitration::compensation_claim, not by owner withdrawals. Owner can only withdraw via compensation_fund_withdraw (requires bPaused=true + lock_duration expired).`,
+                affected_stakeholders: ["owner", "arbitrator", "customer"],
+                scenario: "Owner confuses compensation_fund with general Treasury",
+                mitigation: "Use external Treasury (referenced via order_allocators.sharing.who=Entity) for general funds. Use compensation_fund only for arbitration payouts.",
+                evidence: `deposit=${ctx.compensation_fund_add.balance}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_2_03 = {
+    id: "R-S-2-03",
+    category: "semantic",
+    trigger: "quote side effect — stock deduction not rolled back on later failure",
+    check: (ctx) => {
+        if (ctx.order_new && ctx.order_new.buy.items.length > 0) {
+            return {
+                id: "R-S-2-03",
+                level: "HIGH",
+                category: "semantic",
+                title: "Order flow: stock deducted at quote stage — NOT rolled back on failure",
+                description: `Order will deduct stock at Stage 3 (quote). If Stages 4-7 fail, stock remains deducted. Customer must manually re-add stock or accept the loss.`,
+                affected_stakeholders: ["owner", "customer"],
+                scenario: "Customer's transaction fails after quote but stock is gone",
+                mitigation: "1) Monitor failed transactions and re-add stock via stock_add. 2) Set sales suspension during high-failure periods. 3) Use small batch orders to limit blast radius.",
+                evidence: `items=${ctx.order_new.buy.items.length}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_2_04 = {
+    id: "R-S-2-04",
+    category: "semantic",
+    trigger: "Discount issuance — verify type and total count semantics",
+    check: (ctx) => {
+        if (ctx.discount) {
+            const count = ctx.discount.count;
+            if (count > MAX_DISCOUNT_TOTAL_COUNT) {
+                return {
+                    id: "R-S-2-04",
+                    level: "MEDIUM",
+                    category: "semantic",
+                    title: "Discount count exceeds total cap",
+                    description: `Issuing ${count} discounts exceeds MAX_DISCOUNT_TOTAL_COUNT ${MAX_DISCOUNT_TOTAL_COUNT}`,
+                    affected_stakeholders: ["owner"],
+                    scenario: "Bulk discount issuance",
+                    mitigation: `Issue in batches of <= 1000 (MAX_DISCOUNT_COUNT_ONCE) and keep total <= ${MAX_DISCOUNT_TOTAL_COUNT}`,
+                    evidence: `count=${count}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_S_2_05 = {
+    id: "R-S-2-05",
+    category: "semantic",
+    trigger: "Order placed without verifying WIP hash — buyer passes empty wip_hash",
+    check: (ctx) => {
+        if (ctx.order_new) {
+            const emptyHashItems = ctx.order_new.buy.items.filter(i => i.wip_hash === "");
+            if (emptyHashItems.length > 0) {
+                return {
+                    id: "R-S-2-05",
+                    level: "MEDIUM",
+                    category: "semantic",
+                    title: "Order with empty wip_hash — SDK auto-fills from sale",
+                    description: `${emptyHashItems.length} item(s) have empty wip_hash. SDK will auto-fill from sale.wip_hash at order time. If owner updates the WIP file between viewing and ordering, buyer receives the new (potentially different) content.`,
+                    affected_stakeholders: ["customer"],
+                    scenario: "Time-of-check to time-of-use WIP mismatch",
+                    mitigation: "Buyer should explicitly pass the wip_hash they saw when viewing the product. Empty string is convenience but riskier.",
+                    evidence: `empty_hash_items=${emptyHashItems.length}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_S_3_01 = {
+    id: "R-S-3-01",
+    category: "authority",
+    trigger: "publish operation — requires SERVICE_PUBLISH (311) + prerequisites",
+    check: (ctx) => {
+        if (!ctx.publish)
+            return null;
+        const blockers = [];
+        if (!ctx.current_order_allocators_set)
+            blockers.push("order_allocators not set (F-S-18, E_NO_ALLOCATOR)");
+        const compBalance = ctx.current_compensation_fund_balance ?? "0";
+        if (BigInt(compBalance) > 0n && (ctx.current_arbitrations_count ?? 0) === 0) {
+            blockers.push("compensation_fund > 0 but no arbitrations (F-S-19, E_ARBITRATION_NOT_SET_WITH_COMPENSATION_FUND)");
+        }
+        if (blockers.length > 0) {
+            return {
+                id: "R-S-3-01",
+                level: "CRITICAL",
+                category: "authority",
+                title: "Publish blocked — prerequisites not met",
+                description: `Cannot publish: ${blockers.join("; ")}`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner attempts publish without configuring prerequisites",
+                mitigation: "Configure order_allocators (and arbitrations if compensation_fund > 0) before publish",
+                evidence: `blockers=${blockers.length}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_3_02 = {
+    id: "R-S-3-02",
+    category: "authority",
+    trigger: "pause operation — affects new orders but not existing Progress",
+    check: (ctx) => {
+        if (ctx.pause === undefined)
+            return null;
+        return {
+            id: "R-S-3-02",
+            level: "MEDIUM",
+            category: "authority",
+            title: ctx.pause ? "Pausing Service — new orders blocked, existing Progress continues" : "Resuming Service — new orders accepted",
+            description: ctx.pause
+                ? "Service.bPaused = true will reject new orders (E_SERVICE_PAUSED). Existing orders' Progress continues normally."
+                : "Service.bPaused = false will allow new orders again.",
+            affected_stakeholders: ["owner", "customer"],
+            scenario: ctx.pause ? "Owner pauses for maintenance/stockout" : "Owner resumes after maintenance",
+            mitigation: ctx.pause ? "Communicate pause to customers. Use compensation_fund_withdraw only when paused." : "Verify stock levels before resuming.",
+            evidence: `pause=${ctx.pause}`,
+        };
+    },
+};
+const R_S_3_03 = {
+    id: "R-S-3-03",
+    category: "authority",
+    trigger: "buy_guard change — post-publish mutable (unusual exception)",
+    check: (ctx) => {
+        if (ctx.buy_guard === undefined)
+            return null;
+        if (ctx.current_bPublished) {
+            return {
+                id: "R-S-3-03",
+                level: "MEDIUM",
+                category: "authority",
+                title: "buy_guard change post-publish — unusual mutability",
+                description: `buy_guard is the ONLY publish-locked-field exception: it remains mutable post-publish. Other fields (machine/arbitrations/order_allocators) are immutable.`,
+                affected_stakeholders: ["owner", "customer"],
+                scenario: "Owner changes buy_guard strategy after publish (e.g. whitelist → public)",
+                mitigation: "Document buy_guard changes for transparency. Customers should re-verify buy_guard before ordering.",
+                evidence: `buy_guard=${ctx.buy_guard ?? "(cleared)"}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_3_04 = {
+    id: "R-S-3-04",
+    category: "authority",
+    trigger: "Ownership transfer (builder field) — irreversible",
+    check: (ctx) => {
+        if (!ctx.builder)
+            return null;
+        return {
+            id: "R-S-3-04",
+            level: "HIGH",
+            category: "authority",
+            title: "Service ownership transfer — IRREVERSIBLE",
+            description: `Transferring Service to ${ctx.builder}. Original owner loses ALL control. New owner inherits permission + compensation_fund + all bindings.`,
+            affected_stakeholders: ["owner"],
+            scenario: "Owner transfers Service to new address",
+            mitigation: "1) Verify new owner address twice. 2) Withdraw compensation_fund first (if applicable). 3) Export Service JSON before transfer.",
+            evidence: `new_owner=${ctx.builder}`,
+        };
+    },
+};
+const R_S_4_01 = {
+    id: "R-S-4-01",
+    category: "lifecycle",
+    trigger: "publish is irreversible — bPublished cannot be reset to false",
+    check: (ctx) => {
+        if (!ctx.publish)
+            return null;
+        if (ctx.current_bPublished) {
+            return {
+                id: "R-S-4-01",
+                level: "HIGH",
+                category: "lifecycle",
+                title: "Service already published — publish is no-op",
+                description: "Service.bPublished is already true. Subsequent publish calls have no effect (bPublished is one-shot, cannot revert).",
+                affected_stakeholders: ["owner"],
+                scenario: "Owner calls publish again on already-published Service",
+                mitigation: "Skip publish if already published. To 'reset' a Service, create a new one.",
+                evidence: `bPublished=true`,
+            };
+        }
+        return {
+            id: "R-S-4-01",
+            level: "HIGH",
+            category: "lifecycle",
+            title: "Publish is IRREVERSIBLE — 3 fields will be locked forever",
+            description: "Once published: machine (306), arbitrations (308), order_allocators (313) become permanently immutable. bPublished cannot be reset to false. Clone Service to make changes.",
+            affected_stakeholders: ["owner", "customer"],
+            scenario: "Owner publishes Service for the first time",
+            mitigation: "Verify all configurations before publish. Run pre-publish checklist (service-confirm.ts).",
+            evidence: `bPublished=false→true`,
+        };
+    },
+};
+const R_S_4_02 = {
+    id: "R-S-4-02",
+    category: "lifecycle",
+    trigger: "setting_lock_duration add — only-increase mechanism",
+    check: (ctx) => {
+        if (ctx.setting_locked_time_add === undefined)
+            return null;
+        return {
+            id: "R-S-4-02",
+            level: "MEDIUM",
+            category: "lifecycle",
+            title: "setting_lock_duration can only INCREASE",
+            description: `Adding ${ctx.setting_locked_time_add} ms to setting_lock_duration. New value = old + input (safe_add). Cannot be decreased — protects customers from owner reducing lock to withdraw compensation_fund faster.`,
+            affected_stakeholders: ["owner", "customer"],
+            scenario: "Owner extends lock period to build trust",
+            mitigation: "Ensure extension is intentional. Lock affects rewards/compensation_fund_withdraw/compensation_fund_receive.",
+            evidence: `add_ms=${ctx.setting_locked_time_add}`,
+        };
+    },
+};
+const R_S_4_03 = {
+    id: "R-S-4-03",
+    category: "lifecycle",
+    trigger: "machine/arbitrations/order_allocators modification after publish — SDK blocks",
+    check: (ctx) => {
+        if (!ctx.current_bPublished)
+            return null;
+        const blockedFields = [];
+        if (ctx.machine !== undefined)
+            blockedFields.push("machine (306)");
+        if (ctx.arbitrations !== undefined)
+            blockedFields.push("arbitrations (308)");
+        if (ctx.order_allocators !== undefined)
+            blockedFields.push("order_allocators (313)");
+        if (blockedFields.length > 0) {
+            return {
+                id: "R-S-4-03",
+                level: "HIGH",
+                category: "lifecycle",
+                title: "Post-publish modification blocked by SDK",
+                description: `Service is published. Cannot modify: ${blockedFields.join(", ")}. SDK checkNotPublished() will abort. To change these fields, clone the Service.`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner attempts to change locked field post-publish",
+                mitigation: "Create a new Service with the desired configuration. Migrate active orders if needed.",
+                evidence: `blocked=${blockedFields.join(",")}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_4_04 = {
+    id: "R-S-4-04",
+    category: "lifecycle",
+    trigger: "sales modification — stock/price changes affect future orders only",
+    check: (ctx) => {
+        if (!ctx.sales)
+            return null;
+        return {
+            id: "R-S-4-04",
+            level: "LOW",
+            category: "lifecycle",
+            title: "Sales modification affects future orders only",
+            description: "Sales add/set/remove/clear changes do NOT affect already-created Orders. Existing Orders' Progress continues with the original sale parameters.",
+            affected_stakeholders: ["owner", "customer"],
+            scenario: "Owner updates prices mid-campaign",
+            mitigation: "Communicate price/stock changes to customers. Existing orders are unaffected.",
+            evidence: `sales_op=${ctx.sales.op}`,
+        };
+    },
+};
+const R_S_5_01 = {
+    id: "R-S-5-01",
+    category: "cross_object",
+    trigger: "Machine binding — post-publish immutable, Progress inherits",
+    check: (ctx) => {
+        if (ctx.machine === undefined)
+            return null;
+        if (ctx.current_bPublished) {
+            return {
+                id: "R-S-5-01",
+                level: "HIGH",
+                category: "cross_object",
+                title: "Machine binding immutable post-publish",
+                description: `Service is published; machine cannot be changed. All future Progress objects will use the bound Machine.`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner wants to upgrade workflow post-publish",
+                mitigation: "Create new Service with new Machine. Migrate customers via discounts.",
+                evidence: `machine=${ctx.machine ?? "(cleared)"}`,
+            };
+        }
+        return {
+            id: "R-S-5-01",
+            level: "MEDIUM",
+            category: "cross_object",
+            title: "Machine binding — verify Machine is published",
+            description: `Binding Machine ${ctx.machine}. Ensure Machine is published (machine::publish) — Service cannot bind unpublished Machine.`,
+            affected_stakeholders: ["owner"],
+            scenario: "Owner binds Machine before publishing Service",
+            mitigation: "Verify Machine.bPublished = true before binding.",
+            evidence: `machine=${ctx.machine}`,
+        };
+    },
+};
+const R_S_5_02 = {
+    id: "R-S-5-02",
+    category: "cross_object",
+    trigger: "Arbitration binding — required when compensation_fund > 0",
+    check: (ctx) => {
+        if (!ctx.arbitrations)
+            return null;
+        const compBalance = ctx.current_compensation_fund_balance ?? "0";
+        if (BigInt(compBalance) > 0n && (ctx.current_arbitrations_count ?? 0) === 0) {
+            return {
+                id: "R-S-5-02",
+                level: "HIGH",
+                category: "cross_object",
+                title: "Arbitration required — compensation_fund has balance",
+                description: `compensation_fund balance is ${compBalance}. Publish will fail (E_ARBITRATION_NOT_SET_WITH_COMPENSATION_FUND) until arbitrations is non-empty.`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner deposits compensation_fund without configuring arbitrations",
+                mitigation: "Add at least 1 Arbitration object before publish.",
+                evidence: `compensation_fund=${compBalance}`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_5_03 = {
+    id: "R-S-5-03",
+    category: "cross_object",
+    trigger: "order_allocators binding — publish prerequisite, post-publish immutable",
+    check: (ctx) => {
+        if (ctx.order_allocators === undefined)
+            return null;
+        if (ctx.current_bPublished) {
+            return {
+                id: "R-S-5-03",
+                level: "HIGH",
+                category: "cross_object",
+                title: "order_allocators immutable post-publish",
+                description: "Service is published; order_allocators cannot be changed. Fund distribution strategy is permanently locked.",
+                affected_stakeholders: ["owner"],
+                scenario: "Owner wants to adjust fee split post-publish",
+                mitigation: "Create new Service with new allocators. Cannot migrate existing Orders.",
+                evidence: `order_allocators=${ctx.order_allocators ? "(set)" : "(cleared)"}`,
+            };
+        }
+        if (ctx.publish && !ctx.order_allocators) {
+            return {
+                id: "R-S-5-03",
+                level: "CRITICAL",
+                category: "cross_object",
+                title: "Publish without order_allocators — will fail",
+                description: "Publish will abort with E_NO_ALLOCATOR. order_allocators is a mandatory publish prerequisite.",
+                affected_stakeholders: ["owner"],
+                scenario: "Owner attempts publish without configuring allocators",
+                mitigation: "Set order_allocators before publish.",
+                evidence: `order_allocators=null`,
+            };
+        }
+        return null;
+    },
+};
+const R_S_5_04 = {
+    id: "R-S-5-04",
+    category: "cross_object",
+    trigger: "Repository/Reward binding — verify object types before adding",
+    check: (ctx) => {
+        if (ctx.repositories && (ctx.repositories.op === "add" || ctx.repositories.op === "set")) {
+            return {
+                id: "R-S-5-04",
+                level: "LOW",
+                category: "cross_object",
+                title: "Repository binding — verify object types",
+                description: `Adding ${ctx.repositories.objects.length} repositories. SDK uses queryObjectsWithType to validate each is ObjectType.Repository before binding.`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner adds non-Repository object by mistake",
+                mitigation: "Use LocalMark names or addresses that are confirmed Repository objects.",
+                evidence: `objects=${ctx.repositories.objects.length}`,
+            };
+        }
+        if (ctx.rewards && (ctx.rewards.op === "add" || ctx.rewards.op === "set")) {
+            return {
+                id: "R-S-5-04",
+                level: "LOW",
+                category: "cross_object",
+                title: "Reward binding — verify object types + lock_duration",
+                description: `Adding ${ctx.rewards.objects.length} rewards. SDK validates ObjectType.Reward. Note: rewards modification is locked by setting_lock_duration.`,
+                affected_stakeholders: ["owner"],
+                scenario: "Owner adds Reward objects",
+                mitigation: "Verify Reward objects exist and are active. Be aware of lock_duration implications.",
+                evidence: `objects=${ctx.rewards.objects.length}`,
+            };
+        }
+        return null;
+    },
+};
+const ALL_RULES = [
+    R_S_1_01, R_S_1_02, R_S_1_03, R_S_1_04, R_S_1_05,
+    R_S_2_01, R_S_2_02, R_S_2_03, R_S_2_04, R_S_2_05,
+    R_S_3_01, R_S_3_02, R_S_3_03, R_S_3_04,
+    R_S_4_01, R_S_4_02, R_S_4_03, R_S_4_04,
+    R_S_5_01, R_S_5_02, R_S_5_03, R_S_5_04,
+];
+export const SERVICE_RISK_VERSION = "1.0.0";
+export function getAllServiceRiskRules() {
+    return [...ALL_RULES];
+}
+export function getServiceRiskRulesCount() {
+    return ALL_RULES.length;
+}
+export function getServiceRiskRulesByCategory(category) {
+    return ALL_RULES.filter(r => r.category === category);
+}
+export function assessServiceRisks(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}`);
+        }
+    }
+    return {
+        summary: `Assessed ${risks.length} risk(s) across ${Object.keys(byCategory).length} categories`,
+        risks,
+        overall_risk: overall,
+        risks_by_category: byCategory,
+        stakeholder_advice: advice,
+        needs_human_review: risks.some(r => r.level === "CRITICAL" || r.level === "HIGH"),
+    };
+}

package/dist/knowledge/service-templates.d.ts

@@ -0,0 +1,39 @@
+export type TemplateParamType = "address" | "string" | "number" | "string[]" | "object";
+export interface ServiceTemplateParam {
+    name: string;
+    type: TemplateParamType;
+    description: string;
+    required: boolean;
+    default?: string | number | string[] | object;
+}
+export interface ServiceTemplate {
+    id: string;
+    name: string;
+    description: string;
+    applicable_scenes: string[];
+    industry_tags: string[];
+    params: ServiceTemplateParam[];
+    body: (params: Record<string, string | number | string[] | object>) => object;
+    notes?: string[];
+    post_publish_considerations?: string[];
+}
+export declare const SERVICE_TEMPLATES: ServiceTemplate[];
+export declare const SERVICE_TEMPLATES_VERSION = "1.0.0";
+export declare function getAllServiceTemplates(): ServiceTemplate[];
+export declare function getServiceTemplateById(id: string): ServiceTemplate | undefined;
+export declare function getServiceTemplatesByScene(sceneId: string): ServiceTemplate[];
+export declare function getServiceTemplatesByIndustry(industry: string): ServiceTemplate[];
+export declare function suggestServiceTemplateForScene(sceneId: string): ServiceTemplate | undefined;
+export declare function listServiceTemplates(): {
+    id: string;
+    name: string;
+    description: string;
+    scenes: string[];
+}[];
+export interface FillServiceTemplateResult {
+    ok: boolean;
+    body?: object;
+    error?: string;
+    missing_required?: string[];
+}
+export declare function fillServiceTemplate(templateId: string, params: Record<string, string | number | string[] | object>): FillServiceTemplateResult;