@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/knowledge/reward-puzzle.js

@@ -184,7 +184,7 @@ export function validateConstraints(puzzle) {
                 constraint_id: "F-R-09",
                 severity: "HIGH",
                 message: "Guard's expected progress.current value does not match business intent — " +
-                    "praise reward (好评/wonder) must check 'wonder' node, not 'completed'. " +
+                    "praise reward (praise/wonder) must check 'wonder' node, not 'completed'. " +
                     "Guard is immutable after creation; mismatch requires full rebuild.",
             });
         }

package/dist/knowledge/reward-risk.js

@@ -472,7 +472,7 @@ const R_R_5_03 = {
 const R_R_6_01 = {
     id: "R-R-6-01",
     category: "business_semantic",
-    trigger: "intent mentions praise/好评 but Guard checks non-wonder progress node",
+    trigger: "intent mentions praise/positive-review but Guard checks non-wonder progress node",
     check: (ctx) => {
         if (!ctx.user_intent_phrases || ctx.user_intent_phrases.length === 0)
             return null;
@@ -480,8 +480,8 @@ const R_R_6_01 = {
             return null;
         const intentLower = ctx.user_intent_phrases.join(" ").toLowerCase();
         const praiseKeywords = [
-            "好评", "praise", "wonder", "thumbs_up",
-            "positive review", "satisfaction reward", "好评奖励",
+            "praise", "wonder", "thumbs_up",
+            "positive review", "satisfaction reward", "praise reward",
         ];
         const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
         if (!isPraiseIntent)
@@ -495,10 +495,10 @@ const R_R_6_01 = {
                 level: "HIGH",
                 category: "business_semantic",
                 title: `Guard checks progress=="${expected}" but intent indicates praise reward (wonder node)`,
-                description: `User intent mentions praise/好评/wonder, which maps to the 'wonder' progress node ` +
+                description: `User intent mentions praise/positive-review/wonder, which maps to the 'wonder' progress node ` +
                     `(customer gives positive review AFTER service completion). But the Guard's table bakes ` +
                     `expected state="${expected}", allowing reward claim at the wrong lifecycle stage. ` +
-                    `This violates the business semantics: "好评奖励" should only be claimable AFTER the ` +
+                    `This violates the business semantics: "praise reward" should only be claimable AFTER the ` +
                     `customer advances to the 'wonder' node, not before. ` +
                     `Guard is immutable — fixing this requires creating a new Guard + Reward pair.`,
                 affected_stakeholders: ["owner", "service_provider", "claimer"],
@@ -526,8 +526,8 @@ const R_R_6_02 = {
             return null;
         const intentLower = ctx.user_intent_phrases.join(" ").toLowerCase();
         const praiseKeywords = [
-            "好评", "praise", "wonder", "thumbs_up",
-            "positive review", "satisfaction reward", "好评奖励",
+            "praise", "wonder", "thumbs_up",
+            "positive review", "satisfaction reward", "praise reward",
         ];
         const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
         if (isPraiseIntent)
@@ -538,12 +538,12 @@ const R_R_6_02 = {
             category: "business_semantic",
             title: "Guard checks wonder node but intent does not mention praise",
             description: `Guard's expected progress state is "wonder" (positive-review node), but the user intent ` +
-                `does not mention any praise/好评 keyword. This may be a copy-paste from a wonder_praise ` +
+                `does not mention any praise/positive-review keyword. This may be a copy-paste from a wonder_praise ` +
                 `template without adjusting the Guard for the actual business semantics. If this is a ` +
                 `general feedback reward (wonder_feedback), this is fine. Otherwise, verify the node choice.`,
             affected_stakeholders: ["owner"],
             scenario: "Designer copies wonder_praise template but actually wants a completion-based reward",
-            mitigation: "Verify: if intent is praise reward, add '好评/praise' to description. " +
+            mitigation: "Verify: if intent is praise reward, add 'praise/positive review' to description. " +
                 "If intent is completion-based reward, change Guard to check 'completed' node.",
             evidence: `expected_state="wonder", intent="${intentLower}" (no praise keyword)`,
             auto_fixable: false,

package/dist/knowledge/reward-templates.js

@@ -165,13 +165,13 @@ export function listRewardTemplates() {
 export function suggestRewardTemplate(intent) {
     const lower = intent.toLowerCase();
     if (lower.includes("wonder") || lower.includes("praise") || lower.includes("thumbs_up")
-        || lower.includes("好评") || lower.includes("positive review")
+        || lower.includes("praise") || lower.includes("positive review")
         || lower.includes("satisfaction reward")) {
         return getRewardTemplate("wonder_praise");
     }
     if (lower.includes("feedback") || lower.includes("review collection")
         || lower.includes("no_wonder") || lower.includes("thumbs_down")
-        || lower.includes("差评") || lower.includes("both sentiment")) {
+        || lower.includes("complaint") || lower.includes("both sentiment")) {
         return getRewardTemplate("wonder_feedback");
     }
     if (lower.includes("first order") || lower.includes("new") || lower.includes("first")) {

package/dist/knowledge/safety-rules.d.ts

@@ -33,4 +33,86 @@ export declare function getAmountThreshold(): bigint;
 export declare function formatAmount(value: string | bigint, precision?: bigint): string;
 export declare function collectDefaultWarnings(env: any, data: any): string[];
 export declare const CONFIRMATION_RULES: ConfirmationRule[];
-export declare const SAFETY_RULES_VERSION = 1;
+export declare function extractAmount(data: any): string | null;
+export type ReuseRecommendation = "always_reuse" | "strongly_recommended" | "recommended" | "optional";
+export interface ObjectReuseRule {
+    rule_id: string;
+    object_type: string;
+    recommendation: ReuseRecommendation;
+    reason: string;
+    ask_user: string;
+}
+export declare const OBJECT_REUSE_RULES: readonly ObjectReuseRule[];
+export declare const CREATE_VS_MODIFY_PATTERN: {
+    readonly reuse_form: "string";
+    readonly create_form: "object";
+    readonly resolution_api: "GetObjectExisted";
+    readonly note: "String reference = REUSE (name resolution failure is a hard error); object shape = CREATE (always).";
+};
+export interface ImmutabilityRule {
+    rule_id: string;
+    object_type: string;
+    trigger: "create" | "publish";
+    immutable_fields: string[];
+    mutable_after?: string[];
+    message: string;
+}
+export declare const IMMUTABILITY_RULES: readonly ImmutabilityRule[];
+export type OperationClass = "LOCAL_ONLY" | "ONCHAIN" | "QUERY" | "ENCRYPTED";
+export declare const OPERATION_TYPE_CLASSIFICATION: Record<OperationClass, readonly string[]>;
+export interface OperationClassMeta {
+    gas: boolean;
+    confirmation_required: boolean;
+    note: string;
+}
+export declare const OPERATION_CLASS_META: Record<OperationClass, OperationClassMeta>;
+export declare function classifyTool(toolName: string): OperationClass | undefined;
+export declare const NAMING_CONVENTIONS: {
+    readonly scheme: "<projectPrefix>_<type>_<purpose>_<version>";
+    readonly parts: {
+        readonly project_prefix: {
+            readonly example: "shopFunny_";
+            readonly purpose: "Prevents cross-project collisions";
+        };
+        readonly type_prefix: {
+            readonly example: "machine_ / guard_ / service_";
+            readonly purpose: "Clarifies object type";
+        };
+        readonly purpose_suffix: {
+            readonly example: "serviceWithdraw";
+            readonly purpose: "Describes function";
+        };
+        readonly version_suffix: {
+            readonly example: "_v2";
+            readonly purpose: "Enables iteration without replaceExistName";
+        };
+    };
+    readonly entry_id: {
+        readonly pattern: "^<object_type>:<name>$";
+        readonly example: "service:myshop_service";
+    };
+    readonly replace_exist_name: {
+        readonly default: false;
+        readonly false_effect: "Throws error if name is in use — safe default";
+        readonly true_effect: "Existing object/account with the same name is suspended/unbound to free the name";
+        readonly account_default_forbidden: "replaceExistName:true on the default account (name='') is FORBIDDEN — use suspend() explicitly";
+        readonly recommendation: "DISCOURAGED — prefer versioned names (_v1, _v2) for production";
+    };
+    readonly recommendations: readonly ["Always provide tags on object creation for filtering and management", "Use names as primary identifiers; use short address form (0x1234...def) only for display", "All cross-object references (Guard tables, Service bindings, Machine forwards) use NAMES — resolved per-network at build time"];
+};
+export interface SafetyRiskItem {
+    rule_id: string;
+    severity: "info" | "warn";
+    message: string;
+}
+export declare function checkObjectReuseRules(planned: readonly {
+    object_type: string;
+    is_new: boolean;
+    name?: string;
+}[]): SafetyRiskItem[];
+export declare function checkImmutabilityRules(ops: readonly {
+    object_type: string;
+    trigger: "create" | "publish";
+    name?: string;
+}[]): SafetyRiskItem[];
+export declare const SAFETY_RULES_VERSION = 2;

package/dist/knowledge/safety-rules.js

@@ -217,7 +217,7 @@ export const CONFIRMATION_RULES = [
         bypass_on_explicit_intent: ["test guard", "testing guard", "gen passport", "generate passport"],
     },
 ];
-function extractAmount(data) {
+export function extractAmount(data) {
     if (!data)
         return null;
     const candidates = [
@@ -237,4 +237,168 @@ function extractAmount(data) {
     }
     return null;
 }
-export const SAFETY_RULES_VERSION = 1;
+export const OBJECT_REUSE_RULES = [
+    {
+        rule_id: "REUSE-001",
+        object_type: "permission",
+        recommendation: "strongly_recommended",
+        reason: "Centralized permission control across all services",
+        ask_user: "Do you have an existing Permission to reuse? Provide the name or ID.",
+    },
+    {
+        rule_id: "REUSE-002",
+        object_type: "machine",
+        recommendation: "recommended",
+        reason: "Save design time for similar processes",
+        ask_user: "Do you have an existing Machine whose workflow fits? Provide the name or ID.",
+    },
+    {
+        rule_id: "REUSE-003",
+        object_type: "guard",
+        recommendation: "recommended",
+        reason: "Avoid redundant validation rules",
+        ask_user: "Do you have an existing Guard with matching validation logic? Provide the name or ID.",
+    },
+    {
+        rule_id: "REUSE-004",
+        object_type: "contact",
+        recommendation: "recommended",
+        reason: "Single point of customer-service management",
+        ask_user: "Do you have an existing Contact for customer service? Provide the name or ID.",
+    },
+    {
+        rule_id: "REUSE-005",
+        object_type: "arbitration",
+        recommendation: "always_reuse",
+        reason: "Customers choose from established arbiters; creating a new Arbitration is an operator-level decision",
+        ask_user: "Which existing Arbitration service should disputes route to? Provide the name or ID.",
+    },
+];
+export const CREATE_VS_MODIFY_PATTERN = {
+    reuse_form: "string",
+    create_form: "object",
+    resolution_api: "GetObjectExisted",
+    note: "String reference = REUSE (name resolution failure is a hard error); object shape = CREATE (always).",
+};
+export const IMMUTABILITY_RULES = [
+    {
+        rule_id: "IMMUT-001",
+        object_type: "machine",
+        trigger: "publish",
+        immutable_fields: ["nodes", "pairs", "forwards"],
+        message: "Machine topology is immutable after publish — verify all nodes/forwards via machineNode2file BEFORE publishing",
+    },
+    {
+        rule_id: "IMMUT-002",
+        object_type: "service",
+        trigger: "publish",
+        immutable_fields: ["machine", "order_allocators", "arbitrations"],
+        mutable_after: ["sales"],
+        message: "Service.machine, order_allocators and arbitrations are frozen after publish; sales remains fully modifiable (L3) without pause",
+    },
+    {
+        rule_id: "IMMUT-003",
+        object_type: "guard",
+        trigger: "create",
+        immutable_fields: ["table", "root", "rely"],
+        message: "Guard is CREATE-only and immutable — cannot be edited or deleted after creation. To change: export via guard2file → edit → CREATE new → rebind",
+    },
+];
+export const OPERATION_TYPE_CLASSIFICATION = {
+    LOCAL_ONLY: [
+        "account_operation",
+        "local_mark_operation",
+        "local_info_operation",
+        "project_operation",
+        "config_operation",
+    ],
+    ONCHAIN: [
+        "onchain_operations",
+        "wip_file",
+        "bridge_operation",
+        "messenger_operation",
+    ],
+    QUERY: [
+        "query_toolkit",
+        "onchain_table_data",
+        "onchain_events",
+        "guard2file",
+        "machineNode2file",
+        "schema_query",
+        "wowok_buildin_info",
+        "trust_score",
+    ],
+    ENCRYPTED: [
+        "messenger_operation",
+    ],
+};
+export const OPERATION_CLASS_META = {
+    LOCAL_ONLY: { gas: false, confirmation_required: false, note: "Local state only — no gas, no confirmation needed" },
+    ONCHAIN: { gas: true, confirmation_required: true, note: "On-chain write — gas consumed, explicit user confirmation REQUIRED before execution" },
+    QUERY: { gas: false, confirmation_required: false, note: "Read-only — no gas, no confirmation needed" },
+    ENCRYPTED: { gas: false, confirmation_required: false, note: "Local encryption — no gas, no confirmation needed" },
+};
+export function classifyTool(toolName) {
+    if (OPERATION_TYPE_CLASSIFICATION.ENCRYPTED.includes(toolName))
+        return "ENCRYPTED";
+    for (const cls of ["LOCAL_ONLY", "ONCHAIN", "QUERY"]) {
+        if (OPERATION_TYPE_CLASSIFICATION[cls].includes(toolName))
+            return cls;
+    }
+    return undefined;
+}
+export const NAMING_CONVENTIONS = {
+    scheme: "<projectPrefix>_<type>_<purpose>_<version>",
+    parts: {
+        project_prefix: { example: "shopFunny_", purpose: "Prevents cross-project collisions" },
+        type_prefix: { example: "machine_ / guard_ / service_", purpose: "Clarifies object type" },
+        purpose_suffix: { example: "serviceWithdraw", purpose: "Describes function" },
+        version_suffix: { example: "_v2", purpose: "Enables iteration without replaceExistName" },
+    },
+    entry_id: { pattern: "^<object_type>:<name>$", example: "service:myshop_service" },
+    replace_exist_name: {
+        default: false,
+        false_effect: "Throws error if name is in use — safe default",
+        true_effect: "Existing object/account with the same name is suspended/unbound to free the name",
+        account_default_forbidden: "replaceExistName:true on the default account (name='') is FORBIDDEN — use suspend() explicitly",
+        recommendation: "DISCOURAGED — prefer versioned names (_v1, _v2) for production",
+    },
+    recommendations: [
+        "Always provide tags on object creation for filtering and management",
+        "Use names as primary identifiers; use short address form (0x1234...def) only for display",
+        "All cross-object references (Guard tables, Service bindings, Machine forwards) use NAMES — resolved per-network at build time",
+    ],
+};
+export function checkObjectReuseRules(planned) {
+    const risks = [];
+    for (const p of planned) {
+        if (!p.is_new)
+            continue;
+        const rule = OBJECT_REUSE_RULES.find((r) => r.object_type === p.object_type);
+        if (!rule)
+            continue;
+        if (rule.recommendation === "always_reuse" || rule.recommendation === "strongly_recommended") {
+            risks.push({
+                rule_id: rule.rule_id,
+                severity: rule.recommendation === "always_reuse" ? "warn" : "info",
+                message: `Creating NEW ${p.object_type}${p.name ? ` "${p.name}"` : ""} — reuse is ${rule.recommendation}: ${rule.reason}. ${rule.ask_user}`,
+            });
+        }
+    }
+    return risks;
+}
+export function checkImmutabilityRules(ops) {
+    const risks = [];
+    for (const op of ops) {
+        const rule = IMMUTABILITY_RULES.find((r) => r.object_type === op.object_type && r.trigger === op.trigger);
+        if (!rule)
+            continue;
+        risks.push({
+            rule_id: rule.rule_id,
+            severity: "warn",
+            message: `${op.object_type}${op.name ? ` "${op.name}"` : ""} ${op.trigger}: ${rule.message}. Immutable: [${rule.immutable_fields.join(", ")}]${rule.mutable_after ? `. Still mutable: [${rule.mutable_after.join(", ")}]` : ""}`,
+        });
+    }
+    return risks;
+}
+export const SAFETY_RULES_VERSION = 2;

package/dist/knowledge/scenario-modes.d.ts

@@ -50,4 +50,4 @@ export declare function getScenarioMode(name: IndustryModeName): ScenarioMode |
 export declare function listScenarioModes(): ScenarioMode[];
 export declare function getShippedModes(): ScenarioMode[];
 export declare function getModeCompositions(name: IndustryModeName): ModeComposition[];
-export declare const SCENARIO_MODES_VERSION = 1;
+export declare const SCENARIO_MODES_VERSION = 2;

package/dist/knowledge/scenario-modes.js

@@ -18,8 +18,7 @@ export const SCENARIO_MODES = [
             { name: "delivered", role: "Deliverable available for review" },
             { name: "accepted", role: "Customer signs acceptance" },
             { name: "completed", role: "Funds released to provider" },
-            { name: "refunded", role: "Customer-initiated refund path" },
-            { name: "cancelled", role: "Pre-delivery cancellation" },
+            { name: "cancelled", role: "Pre-delivery cancellation — triggers refund Allocator" },
         ],
         guards: [
             { template_id: "buy_guard_identity", host: "service", purpose: "Customer identity check on purchase" },
@@ -33,13 +32,14 @@ export const SCENARIO_MODES = [
             recipient: "signer",
             count: 2,
             mode: "amount",
-            description: "100% to provider on accepted; 100% refund to customer on refunded",
+            description: "100% to provider on completed; 100% refund to customer on cancelled (refund Allocator, off-Machine fund routing per R-M1-11)",
         },
         key_risk: "Customer never accepts delivery — provider cannot get paid",
         build_notes: [
             "Use Service `setting_locked_time` to lock rules for the engagement duration",
             "WIP hash on deliverable is mandatory — protects provider in disputes",
             "Acceptance gate is the trust pivot — both parties must agree on criteria",
+            "R-M1-11: no 'refunded'/'disputed'/'arb' nodes — refunds route via Allocator (100% to OrderHolder) triggered by 'cancelled', disputes via Arbitration",
             "NEW: Payment exception compensation for delivery delays — provider Treasury auto-compensates customer (§2.13)",
         ],
     },
@@ -62,8 +62,9 @@ export const SCENARIO_MODES = [
             { name: "in_use", role: "Rental period active" },
             { name: "returned", role: "Customer returns item" },
             { name: "inspected", role: "Owner inspects returned item" },
-            { name: "deposit_refunded", role: "No damage — full deposit returned" },
-            { name: "deposit_deducted", role: "Damage found — deposit partially deducted" },
+            { name: "return_approved", role: "No damage — triggers deposit refund Allocator (100% to customer)" },
+            { name: "damage_confirmed", role: "Damage confirmed via pre+post WIP diff — triggers deposit deduction Allocator" },
+            { name: "completed", role: "Rental finalized — triggers rent Allocator (rent to owner)" },
         ],
         guards: [
             { template_id: "deposit_guard_amount", host: "service", purpose: "Verify deposit amount matches listing" },
@@ -78,13 +79,14 @@ export const SCENARIO_MODES = [
             recipient: "entity",
             count: 3,
             mode: "amount",
-            description: "Rent to owner; refund to customer; deduction to owner (damage case)",
+            description: "Rent to owner on completed; deposit refund to customer on return_approved; deposit deduction to owner on damage_confirmed (fund routing via Allocator per R-M1-11)",
         },
         key_risk: "Owner claims damage without pre-rental WIP — customer loses deposit unfairly",
         build_notes: [
             "Pre-rental WIP is non-negotiable — without it, damage claims fail",
             "Deposit must be escrowed, not direct-transferred — enables fair deduction",
             "Inspection gate prevents customer from denying damage",
+            "R-M1-11: no 'deposit_refunded'/'deposit_deducted'/'refunded' nodes — deposit refund/deduction flows through Allocator triggered by return_approved/damage_confirmed business states",
             "NEW: Payment exception compensation for return delays — Treasury withdraws scene-bound Payment (§2.13)",
             "NEW: Repository quote_guard for weather/usage data subscription revenue (§2.11)",
         ],
@@ -106,7 +108,7 @@ export const SCENARIO_MODES = [
             { name: "paid", role: "Entry: enrollment and tuition paid via Service.buy(); Machine starts here" },
             { name: "session_N", role: "Per-session attendance (1..N)" },
             { name: "completed", role: "All sessions delivered" },
-            { name: "refunded", role: "Institution-approved refund" },
+            { name: "withdrawn", role: "Enrollment cancelled mid-course — triggers unearned-tuition refund Allocator" },
         ],
         guards: [
             { template_id: "attendance_guard_signer", host: "machine", purpose: "Per-session student attendance signature" },
@@ -117,7 +119,7 @@ export const SCENARIO_MODES = [
             recipient: "entity",
             count: 1,
             mode: "amount",
-            description: "1/N of tuition released per session attendance; unearned portion refundable",
+            description: "1/N of tuition released per session attendance; unearned portion refunded to student via Allocator on withdrawn (per R-M1-11)",
         },
         key_risk: "Tutoring institutions run away with prepaid tuition",
         build_notes: [
@@ -147,7 +149,7 @@ export const SCENARIO_MODES = [
             { name: "segment_D2", role: "Segment 2 (e.g., guided tour)" },
             { name: "returned", role: "Trip completed, customer returns" },
             { name: "completed", role: "All segments delivered, funds released" },
-            { name: "refunded", role: "Trip interruption refund" },
+            { name: "interrupted", role: "Trip interrupted — triggers refund Allocator (undelivered segments) or Arbitration" },
         ],
         guards: [
             { template_id: "segment_guard_wip", host: "machine", purpose: "Per-segment arrival WIP (hotel check-in, etc.)" },
@@ -160,7 +162,7 @@ export const SCENARIO_MODES = [
             recipient: "entity",
             count: 3,
             mode: "amount",
-            description: "Deposit 20% to agency, final 80% to agency, then agency-side Allocation splits to hotel/guide/driver per segment",
+            description: "Deposit 20% to agency, final 80% to agency, then agency-side Allocation splits to hotel/guide/driver per segment; undelivered segments refunded to customer via Allocator on interrupted (per R-M1-11)",
         },
         key_risk: "Paid in full then service shrinks — multi-tier transparency prevents this",
         build_notes: [
@@ -316,4 +318,4 @@ export function getShippedModes() {
 export function getModeCompositions(name) {
     return MODE_COMPOSITIONS.filter((c) => c.modes.includes(name));
 }
-export const SCENARIO_MODES_VERSION = 1;
+export const SCENARIO_MODES_VERSION = 2;

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

@@ -111,7 +111,7 @@ export interface ServiceJsonForConfirm {
     };
     compensation_fund_withdraw?: unknown;
     compensation_fund_receive?: unknown;
-    setting_locked_time_add?: number;
+    setting_lock_duration_add?: number;
     order_new?: {
         buy: {
             items: Array<{

package/dist/knowledge/service-confirm.js

@@ -263,7 +263,7 @@ function adaptRiskAssessment(input) {
         order_allocators: input.service_json.order_allocators,
         buy_guard: input.service_json.buy_guard,
         compensation_fund_add: input.service_json.compensation_fund_add,
-        setting_locked_time_add: input.service_json.setting_locked_time_add,
+        setting_lock_duration_add: input.service_json.setting_lock_duration_add,
         compensation_fund_receive: input.service_json.compensation_fund_receive,
         owner_receive: input.service_json.owner_receive,
         pause: input.service_json.pause,
@@ -761,8 +761,8 @@ function generateConfirmationText(input, checklist, assessment) {
         lines.push(`- Compensation fund deposit: ${data.compensation_fund_add.balance}`);
     if (data.compensation_fund_withdraw)
         lines.push(`- ⚠️ Compensation fund withdraw (requires paused + lock expired)`);
-    if (data.setting_locked_time_add !== undefined)
-        lines.push(`- Setting lock +${data.setting_locked_time_add}ms`);
+    if (data.setting_lock_duration_add !== undefined)
+        lines.push(`- Setting lock +${data.setting_lock_duration_add}ms`);
     if (data.order_new)
         lines.push(`- ⚠️ ORDER NEW (8-stage flow, stock deducted at quote)`);
     if (data.builder)

package/dist/knowledge/service-context.js

@@ -58,7 +58,7 @@ export function buildServiceContext(input) {
             order_allocators: input.service_json.order_allocators,
             buy_guard: input.service_json.buy_guard,
             compensation_fund_add: input.service_json.compensation_fund_add,
-            setting_locked_time_add: input.service_json.setting_locked_time_add,
+            setting_lock_duration_add: input.service_json.setting_lock_duration_add,
             compensation_fund_receive: input.service_json.compensation_fund_receive,
             owner_receive: input.service_json.owner_receive,
             pause: input.service_json.pause,

package/dist/knowledge/service-ledger.js

@@ -15,7 +15,7 @@ export const SERVICE_PERMISSIONS = [
     { index: 314, name: "SERVICE_COMPENSATION_FUND_WITHDRAW", description: "Withdraw compensation fund (lock_duration)", governed_operation: "service::compensation_fund_withdraw", post_publish_mutability: "locked_by_duration" },
     { index: 315, name: "SERVICE_COMPENSATION_FUND_DEPOSIT", description: "Deposit to compensation fund", governed_operation: "service::compensation_fund_add", post_publish_mutability: "mutable" },
     { index: 316, name: "SERVICE_COMPENSATION_FUND_RECEIVE", description: "Receive compensation fund (lock_duration)", governed_operation: "service::compensation_fund_receive", post_publish_mutability: "locked_by_duration" },
-    { index: 317, name: "SERVICE_COMPENSATION_LOCKED_TIME_ADD", description: "Extend setting_lock_duration (only-increase)", governed_operation: "service::setting_lock_duration_add", post_publish_mutability: "mutable" },
+    { index: 317, name: "SERVICE_COMPENSATION_LOCK_DURATION_ADD", description: "Extend setting_lock_duration (only-increase)", governed_operation: "service::setting_lock_duration_add", post_publish_mutability: "mutable" },
     { index: 318, name: "SERVICE_REWARD", description: "Add/remove Reward references (locked)", governed_operation: "service::reward_add/remove/clear", post_publish_mutability: "locked_by_duration" },
     { index: 319, name: "SERVICE_OWNER_RECEIVE", description: "Receive Payment/objects to owner", governed_operation: "service::owner_receive", post_publish_mutability: "mutable" },
     { index: 320, name: "SERVICE_UM", description: "Bind/unbind Contact as UM", governed_operation: "service::um_set/um_none", post_publish_mutability: "mutable" },

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

@@ -65,7 +65,7 @@ export interface ServiceRiskCheckContext {
     compensation_fund_add?: {
         balance: string | number;
     };
-    setting_locked_time_add?: number;
+    setting_lock_duration_add?: number;
     compensation_fund_receive?: unknown;
     owner_receive?: unknown;
     pause?: boolean;

package/dist/knowledge/service-risk.js

@@ -370,18 +370,18 @@ const R_S_4_02 = {
     category: "lifecycle",
     trigger: "setting_lock_duration add — only-increase mechanism",
     check: (ctx) => {
-        if (ctx.setting_locked_time_add === undefined)
+        if (ctx.setting_lock_duration_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.`,
+            description: `Adding ${ctx.setting_lock_duration_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}`,
+            evidence: `add_ms=${ctx.setting_lock_duration_add}`,
         };
     },
 };

package/dist/knowledge/service-templates.js

@@ -191,7 +191,7 @@ export const SERVICE_TEMPLATES = [
             permission: p.permission_address,
             arbitrations: { op: "add", objects: p.arbitration_addresses },
             compensation_fund_add: { balance: p.compensation_fund_balance },
-            setting_locked_time_add: p.setting_lock_duration_ms,
+            setting_lock_duration_add: p.setting_lock_duration_ms,
             sales: { op: "add", sales: p.service_items },
             order_allocators: [
                 {
@@ -234,7 +234,7 @@ export const SERVICE_TEMPLATES = [
             permission: p.permission_address,
             arbitrations: { op: "add", objects: p.arbitration_addresses },
             compensation_fund_add: { balance: p.initial_deposit },
-            setting_locked_time_add: p.lock_duration_ms,
+            setting_lock_duration_add: p.lock_duration_ms,
             sales: { op: "add", sales: p.service_items },
             order_allocators: [
                 {

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

@@ -80,7 +80,7 @@ export interface ServiceCallDataForExplain {
     };
     compensation_fund_withdraw?: unknown;
     compensation_fund_receive?: unknown;
-    setting_locked_time_add?: number;
+    setting_lock_duration_add?: number;
     order_new?: {
         buy: {
             items: Array<{

package/dist/knowledge/service-translation.js

@@ -185,10 +185,10 @@ export const SEMANTIC_TO_SCHEMA_RULES = [
         pattern_name: "Extend setting_lock_duration",
         semantic_intent: "Add milliseconds to setting_lock_duration (only-increase mechanism)",
         match_keywords: ["setting_lock_duration", "lock_duration", "lock period", "extend lock"],
-        schema_fields: ["object", "setting_locked_time_add"],
+        schema_fields: ["object", "setting_lock_duration_add"],
         example_json: {
             object: "0xSERVICE_ADDRESS",
-            setting_locked_time_add: 2592000000,
+            setting_lock_duration_add: 2592000000,
         },
         reverse_explanation: "Only-increase (safe_add). Default 2592000000ms (30 days). Affects rewards/compensation_fund_withdraw/compensation_fund_receive mutability windows.",
     },
@@ -315,8 +315,8 @@ export const SCHEMA_TO_SEMANTIC_RULES = [
     },
     {
         element_type: "field",
-        type_name: "setting_locked_time_add",
-        semantic_explanation: "Extend setting_lock_duration (only-increase, safe_add). Index 317 (SERVICE_COMPENSATION_LOCKED_TIME_ADD).",
+        type_name: "setting_lock_duration_add",
+        semantic_explanation: "Extend setting_lock_duration (only-increase, safe_add). Index 317 (SERVICE_COMPENSATION_LOCK_DURATION_ADD).",
     },
     {
         element_type: "field",
@@ -454,7 +454,7 @@ export const SERVICE_CONSTRAINT_RULES = [
         id: "MC-S-16",
         category: "lifecycle",
         rule: `setting_lock_duration only-increase (safe_add) — cannot be decreased; protects customers`,
-        applies_to: ["setting_locked_time_add"],
+        applies_to: ["setting_lock_duration_add"],
     },
     {
         id: "MC-S-17",
@@ -572,8 +572,8 @@ export function explainServiceCallData(data) {
     if (data.compensation_fund_receive) {
         lines.push(`- Compensation fund receive (locked by duration)`);
     }
-    if (data.setting_locked_time_add !== undefined) {
-        lines.push(`- Setting lock duration +${data.setting_locked_time_add}ms (only-increase)`);
+    if (data.setting_lock_duration_add !== undefined) {
+        lines.push(`- Setting lock duration +${data.setting_lock_duration_add}ms (only-increase)`);
     }
     if (data.order_new) {
         const o = data.order_new;