@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/guard-lint.d.ts

@@ -34,6 +34,7 @@ export interface GuardJsonInput {
         host_object?: string;
         binding_field?: string;
         action?: string;
+        sharing_recipients?: ("Signer" | "Entity" | "GuardIdentifier")[];
     };
 }
 export interface AutoFixAction {

package/dist/knowledge/guard-lint.js

@@ -81,10 +81,15 @@ async function checkSdkSyntax(json) {
 function checkSemanticErrors(json) {
     const diagnostics = [];
     const { table, root, binding_hint } = json;
+    const scene = binding_hint ? findScene(binding_hint.host_object ?? "", binding_hint.binding_field ?? "") : undefined;
     const submissionEntries = getSubmissionEntries(table);
     if (submissionEntries.length > 0 && root && !hasSignerContext(root)) {
         const hasAddressSubmission = submissionEntries.some((e) => e.value_type === "Address");
-        if (hasAddressSubmission) {
+        const isAllocatorsEntitySharing = scene?.id === "service_order_allocators_guard" &&
+            binding_hint?.sharing_recipients !== undefined &&
+            binding_hint.sharing_recipients.length > 0 &&
+            !binding_hint.sharing_recipients.includes("Signer");
+        if (hasAddressSubmission && !isAllocatorsEntitySharing) {
             const indices = submissionEntries
                 .filter((e) => e.value_type === "Address")
                 .map((e) => table.indexOf(e));
@@ -101,7 +106,6 @@ function checkSemanticErrors(json) {
             });
         }
     }
-    const scene = binding_hint ? findScene(binding_hint.host_object ?? "", binding_hint.binding_field ?? "") : undefined;
     if (scene?.id === "arbitration_voting_guard") {
         const hasWeightSubmission = submissionEntries.some((e) => ["U8", "U16", "U32", "U64", "U128", "U256"].includes(e.value_type ?? ""));
         if (hasWeightSubmission) {
@@ -238,6 +242,22 @@ function checkSyntaxHints(json) {
             });
         }
     }
+    for (let i = 0; i < table.length; i++) {
+        const entry = table[i];
+        if (entry.b_submission === true && entry.value !== undefined && entry.value !== null) {
+            diagnostics.push({
+                code: "SH-11",
+                message: `table[${i}] has a redundant value field on b_submission=true entry (the verifier supplies the value at runtime; this value is ignored by BCS encoding and wastes gas)`,
+                severity: "warning",
+                source: "lint",
+                location: { path: `/table/${i}/value` },
+                fix: {
+                    description: "Remove the value field — it is ignored for b_submission=true entries",
+                    auto_fixable: true,
+                },
+            });
+        }
+    }
     return diagnostics;
 }
 function checkSuggestions(json) {
@@ -324,6 +344,46 @@ function checkSuggestions(json) {
             });
         }
     }
+    if (root) {
+        const rootStr = rootToString(root);
+        const hasProofSigner = rootStr.includes("proof.signer");
+        const hasProofTime = rootStr.includes("proof.time");
+        const hasStringLength = rootStr.includes("calc_string_length");
+        const hasStringSubmission = submissionEntries.some((e) => e.value_type === "String");
+        if (hasProofSigner && hasProofTime) {
+            diagnostics.push({
+                code: "SG-04",
+                message: "Strict-mode privacy-delivery guard detected (proof.signer + proof.time). " +
+                    "Recommended three conditions: Signer==proof.signer (submitter accountability), " +
+                    "proof.time>order.time (freshness), order.service==service (project binding). " +
+                    "No content verification — only submission responsibility ('whoever benefits bears the burden of proof').",
+                severity: "info",
+                source: "lint",
+                location: { path: "/root" },
+                fix: {
+                    description: "Ensure all three conditions are present (logic_and). Refer to template tpl_forward_privacy_delivery_proof. " +
+                        "Query IDs: proof.signer=1958, proof.time=1960, order.time=1574, order.service=1563.",
+                    auto_fixable: false,
+                },
+            });
+        }
+        else if (hasStringLength && hasStringSubmission) {
+            diagnostics.push({
+                code: "SG-04",
+                message: "Broad-mode privacy-delivery guard detected (String submission + length check, e.g. Merkle Root length == 66). " +
+                    "This trusts the submitter's honesty; the counterparty can dispute by checking their own Messenger conversation. " +
+                    "Suitable as an arbitration basis, not a fund-flow gate.",
+                severity: "info",
+                source: "lint",
+                location: { path: "/root" },
+                fix: {
+                    description: "For stronger assurance, consider strict mode: submit a Proof object address (from messenger.submitChainProof) + " +
+                        "Order address, then verify proof.signer/proof.time/order.service. See template tpl_forward_privacy_delivery_proof.",
+                    auto_fixable: false,
+                },
+            });
+        }
+    }
     return diagnostics;
 }
 export function autoFixGuard(json) {
@@ -433,6 +493,20 @@ export function autoFixGuard(json) {
             fixed.rely.guards = unique;
         }
     }
+    for (let i = 0; i < fixed.table.length; i++) {
+        const entry = fixed.table[i];
+        if (entry.b_submission === true && entry.value !== undefined && entry.value !== null) {
+            const before = JSON.stringify(entry.value);
+            delete entry.value;
+            actions.push({
+                diagnostic_code: "SH-11",
+                description: `table[${i}] remove redundant value on b_submission=true entry`,
+                before,
+                after: "(removed)",
+                path: `/table/${i}/value`,
+            });
+        }
+    }
     return { fixed, actions };
 }
 export async function lintGuard(json, options) {
@@ -467,7 +541,13 @@ export async function lintGuard(json, options) {
             name: e.name,
             object_type: e.object_type,
         }));
-        risk_assessment = assessGuardRisks({ table: mappedTable, root, rely, scene });
+        risk_assessment = assessGuardRisks({
+            table: mappedTable,
+            root,
+            rely,
+            scene,
+            sharing_recipients: binding_hint?.sharing_recipients,
+        });
         for (const r of risk_assessment.risks) {
             const severity = r.level === "critical" || r.level === "high" ? "error" :
                 r.level === "medium" ? "warning" :

package/dist/knowledge/guard-migration.d.ts

@@ -0,0 +1,48 @@
+export type GuardNodeType = 'logic_or' | 'logic_and' | 'logic_not' | 'logic_equal' | 'logic_string_nocase_equal' | 'logic_as_u256_equal' | 'logic_string_contains' | 'logic_string_nocase_contains' | 'logic_as_u256_greater' | 'logic_as_u256_lesser' | 'logic_as_u256_greater_or_equal' | 'logic_as_u256_lesser_or_equal' | 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool' | 'identifier' | 'query' | 'context' | 'calc_number_add' | 'calc_number_subtract' | 'calc_number_multiply' | 'calc_number_divide' | 'calc_number_mod' | string;
+export interface GuardNode {
+    type: GuardNodeType;
+    nodes?: GuardNode[];
+    node?: GuardNode;
+    identifier?: number;
+    query?: string | number;
+    context?: string;
+    object?: {
+        identifier?: number;
+        convert_witness?: string | number;
+    };
+    parameters?: unknown[];
+}
+export interface GuardTableEntry {
+    identifier: number;
+    b_submission?: boolean;
+    value_type?: string | number;
+    value?: unknown;
+    name?: string;
+}
+export type VecContainsTarget = 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool';
+export type VecValueType = 'VecString' | 'VecAddress' | 'VecU64' | 'VecU128' | 'VecU256' | 'VecU8' | 'VecU16' | 'VecU32' | 'VecBool';
+export interface ConversionResult {
+    convertible: boolean;
+    targetOperator?: VecContainsTarget;
+    vectorValueType?: VecValueType;
+    sharedNode?: GuardNode;
+    constants?: Array<{
+        identifier: number;
+        value: unknown;
+        value_type: string;
+    }>;
+    reasons?: string[];
+}
+export declare function analyzeLogicOrConversion(orNode: GuardNode, table: GuardTableEntry[]): ConversionResult;
+export interface ShorthandResult {
+    newRoot: GuardNode;
+    removeIdentifiers: number[];
+    addEntry: {
+        identifier: number;
+        b_submission: false;
+        value_type: VecValueType;
+        value: unknown[];
+        name: string;
+    };
+}
+export declare function buildShorthand(orNode: GuardNode, result: ConversionResult, newIdentifier: number): ShorthandResult | null;

package/dist/knowledge/guard-migration.js

@@ -0,0 +1,228 @@
+const EQUAL_OPERATORS = new Set([
+    'logic_equal',
+    'logic_string_nocase_equal',
+    'logic_as_u256_equal',
+]);
+function mapOperatorToTarget(operator, valueType) {
+    if (valueType === 'String' || valueType === 2) {
+        if (operator === 'logic_string_nocase_equal') {
+            return { target: 'vec_contains_string_nocase', vecType: 'VecString' };
+        }
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_string', vecType: 'VecString' };
+        }
+        return null;
+    }
+    if (valueType === 'Address' || valueType === 1) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_address', vecType: 'VecAddress' };
+        }
+        return null;
+    }
+    if (valueType === 'Bool' || valueType === 0) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_bool', vecType: 'VecBool' };
+        }
+        return null;
+    }
+    const numericTypes = new Set([
+        'U8', 'U16', 'U32', 'U64', 'U128', 'U256',
+        3, 4, 5, 6, 7, 8,
+    ]);
+    if (numericTypes.has(valueType)) {
+        if (operator === 'logic_equal' || operator === 'logic_as_u256_equal') {
+            return { target: 'vec_contains_number', vecType: 'VecU256' };
+        }
+        return null;
+    }
+    return null;
+}
+export function analyzeLogicOrConversion(orNode, table) {
+    const reasons = [];
+    if (orNode.type !== 'logic_or') {
+        return {
+            convertible: false,
+            reasons: [`Node type is '${orNode.type}', not 'logic_or'. Only logic_or nodes are candidates.`],
+        };
+    }
+    const children = orNode.nodes ?? [];
+    if (children.length < 2) {
+        return {
+            convertible: false,
+            reasons: [`logic_or has ${children.length} children; need at least 2 to convert.`],
+        };
+    }
+    if (children.length > 7) {
+        return {
+            convertible: false,
+            reasons: [
+                `logic_or has ${children.length} children; vec_contains_* supports at most 7 needles (1 haystack + 7 needles = 8 node limit). Keep the logic_or.`,
+            ],
+        };
+    }
+    const childOperators = new Set();
+    for (const child of children) {
+        if (!EQUAL_OPERATORS.has(child.type)) {
+            if (child.type === 'logic_string_contains' || child.type === 'logic_string_nocase_contains') {
+                reasons.push(`Child uses '${child.type}' (substring match). vec_contains_* is whole-element membership, NOT substring. Cannot convert.`);
+            }
+            else if (child.type?.startsWith('logic_as_u256_greater') || child.type?.startsWith('logic_as_u256_lesser')) {
+                reasons.push(`Child uses '${child.type}' (ordering comparison). vec_contains_* is membership, not ordering. Cannot convert.`);
+            }
+            else if (child.type === 'logic_and' || child.type === 'logic_or' || child.type === 'logic_not') {
+                reasons.push(`Child is a nested logic node ('${child.type}'). Only leaf equal-style comparisons are convertible.`);
+            }
+            else {
+                reasons.push(`Child uses '${child.type}' which is not an equal-style operator (logic_equal / logic_string_nocase_equal / logic_as_u256_equal).`);
+            }
+            return { convertible: false, reasons };
+        }
+        childOperators.add(child.type);
+    }
+    if (childOperators.size > 1) {
+        const opList = Array.from(childOperators).join(', ');
+        return {
+            convertible: false,
+            reasons: [
+                `Children use mixed operators: [${opList}]. Mixing case-sensitive (logic_equal) and case-insensitive (logic_string_nocase_equal) comparisons would change semantics. Keep the logic_or.`,
+            ],
+        };
+    }
+    const sharedOperator = children[0].type;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes ?? [];
+        if (childNodes.length !== 2) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} ('${sharedOperator}') has ${childNodes.length} sub-nodes; expected exactly 2 (one constant side + one shared query side).`,
+                ],
+            };
+        }
+    }
+    const constants = [];
+    let sharedNode = null;
+    let sharedNodeSerial = null;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes;
+        const left = childNodes[0];
+        const right = childNodes[1];
+        const leftIsConstId = left.type === 'identifier' && typeof left.identifier === 'number';
+        const rightIsConstId = right.type === 'identifier' && typeof right.identifier === 'number';
+        if (!leftIsConstId && !rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has no constant identifier side (both sub-nodes are non-identifier). Conversion requires one side to be a constant table entry.`,
+                ],
+            };
+        }
+        if (leftIsConstId && rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has two identifier sides. Conversion requires one side to be a non-constant (query/context/calc) node shared across all children.`,
+                ],
+            };
+        }
+        const constIdNode = leftIsConstId ? left : right;
+        const nonConstNode = leftIsConstId ? right : left;
+        const tableEntry = table.find((e) => e.identifier === constIdNode.identifier);
+        if (!tableEntry) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which is not in the table.`,
+                ],
+            };
+        }
+        if (tableEntry.b_submission !== false) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] with b_submission=${tableEntry.b_submission}. Conversion requires compile-time constants (b_submission=false).`,
+                ],
+            };
+        }
+        if (tableEntry.value === undefined || tableEntry.value === null) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which has no 'value' field. Conversion requires explicit constant values.`,
+                ],
+            };
+        }
+        const nonConstSerial = JSON.stringify(nonConstNode);
+        if (sharedNodeSerial === null) {
+            sharedNodeSerial = nonConstSerial;
+            sharedNode = nonConstNode;
+        }
+        else if (sharedNodeSerial !== nonConstSerial) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i}'s non-constant side differs from child 0's. All children must share the SAME non-constant node (same query, same convert_witness, same parameters). Keep the logic_or.`,
+                ],
+            };
+        }
+        constants.push({
+            identifier: constIdNode.identifier,
+            value: tableEntry.value,
+            value_type: String(tableEntry.value_type ?? ''),
+        });
+    }
+    const valueTypes = new Set(constants.map((c) => c.value_type));
+    if (valueTypes.size > 1) {
+        return {
+            convertible: false,
+            reasons: [
+                `Constants have mixed value_types: [${Array.from(valueTypes).join(', ')}]. All constants must share the same type to form a single VecXxx.`,
+            ],
+        };
+    }
+    const sharedValueType = constants[0].value_type;
+    const mapping = mapOperatorToTarget(sharedOperator, sharedValueType);
+    if (!mapping) {
+        return {
+            convertible: false,
+            reasons: [
+                `No vec_contains_* variant maps to operator='${sharedOperator}' with value_type='${sharedValueType}'. ` +
+                    `Mappable combinations: (logic_string_nocase_equal, String)→vec_contains_string_nocase; ` +
+                    `(logic_equal, String)→vec_contains_string; (logic_equal, Address)→vec_contains_address; ` +
+                    `(logic_equal, Bool)→vec_contains_bool; (logic_equal|logic_as_u256_equal, numeric)→vec_contains_number.`,
+            ],
+        };
+    }
+    return {
+        convertible: true,
+        targetOperator: mapping.target,
+        vectorValueType: mapping.vecType,
+        sharedNode: sharedNode ?? undefined,
+        constants,
+    };
+}
+export function buildShorthand(orNode, result, newIdentifier) {
+    if (!result.convertible || !result.targetOperator || !result.vectorValueType || !result.sharedNode || !result.constants) {
+        return null;
+    }
+    const values = result.constants.map((c) => c.value);
+    const removeIdentifiers = result.constants.map((c) => c.identifier);
+    const newRoot = {
+        type: result.targetOperator,
+        nodes: [
+            { type: 'identifier', identifier: newIdentifier },
+            result.sharedNode,
+        ],
+    };
+    return {
+        newRoot,
+        removeIdentifiers,
+        addEntry: {
+            identifier: newIdentifier,
+            b_submission: false,
+            value_type: result.vectorValueType,
+            value: values,
+            name: 'converted_constants',
+        },
+    };
+}

package/dist/knowledge/guard-puzzle.js

@@ -1,3 +1,4 @@
+import { MAX_SUBMISSION_SIZE_PASSPORT } from "@wowok/wowok";
 export function checkPuzzleCompleteness(puzzle) {
     const dimensions = {
         intent: isIntentComplete(puzzle.intent),
@@ -214,7 +215,7 @@ export function generateConfirmationText(puzzle) {
             ["R1", "Guard immutable=true to verify", puzzle.constraints.runtime_01_guard_immutable],
             ["R2", "submission type bytes match table declaration", puzzle.constraints.runtime_02_submission_type_match],
             ["R3", "b_submission=true entry found in submission", puzzle.constraints.runtime_03_submission_complete],
-            ["R4", "submission total bytes ≤ 256", puzzle.constraints.runtime_04_submission_size],
+            ["R4", `submission total bytes ≤ ${MAX_SUBMISSION_SIZE_PASSPORT}`, puzzle.constraints.runtime_04_submission_size],
             ["R5", "witness derivation source object has related field", puzzle.constraints.runtime_05_witness_source_valid],
             ["R6", "query target object exists and types match", puzzle.constraints.runtime_06_query_object_valid],
         ];
@@ -604,7 +605,7 @@ function deriveConstraints(table, root, rely, collectors) {
     const runtime02 = true;
     const runtime03 = true;
     const submissionEntries = table.filter((t) => t.b_submission);
-    const runtime04 = submissionEntries.length <= 256;
+    const runtime04 = submissionEntries.length <= MAX_SUBMISSION_SIZE_PASSPORT;
     const runtime05 = true;
     const runtime06 = true;
     return {

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

@@ -1,6 +1,6 @@
 import type { GuardScene } from "./guard-ledger.js";
 export type GuardStakeholder = "customer" | "provider" | "arbitrator" | "claimant" | "system";
-export type RiskLevel = "critical" | "high" | "medium" | "low" | "info";
+export type RiskLevel = "critical" | "high" | "medium" | "low";
 export type DataSourceClass = "type1_onchain_constant" | "type2_witness_derived" | "type3_submitted_object" | "type4_system_context" | "cross_type";
 export type RiskCategory = "data_source_trust" | "submission_forgery" | "system_context_risk" | "game_theory" | "logic_gap" | "binding_risk" | "dependency_risk" | "impack_risk" | "rep_risk";
 export interface GuardRisk {
@@ -46,6 +46,7 @@ export interface RiskCheckContext {
     };
     scene?: GuardScene;
     operation_type?: string;
+    sharing_recipients?: ("Signer" | "Entity" | "GuardIdentifier")[];
 }
 export declare function assessGuardRisks(params: {
     table: RiskCheckContext["table"];
@@ -53,6 +54,7 @@ export declare function assessGuardRisks(params: {
     rely?: RiskCheckContext["rely"];
     scene?: GuardScene;
     operation_type?: string;
+    sharing_recipients?: RiskCheckContext["sharing_recipients"];
 }): GuardRiskAssessment;
 export declare function assessGuardRisksForOperation(operation_type: string, data: any): GuardRiskAssessment | null;
 export declare function getRiskSummary(assessment: GuardRiskAssessment): {