@wowok/agent-mcp 2.3.16 → 2.4.1

package/dist/schema/call/semantic.js

@@ -1,9 +1,15 @@
 import { auditService } from "../../knowledge/index.js";
 import { getExperienceFeedback, recordOperationOutcome } from "../../experience/index.js";
 import { isEnabled as isRuntimeEnabled, listServices } from "../../config/index.js";
-import { generateReminders } from "../../customer/reminder-system.js";
+import { generateReminders } from "../../customer/index.js";
 import { getProfile } from "../../experience/user-profile.js";
 import { injectEvolutionContext, recordIndustrySignal } from "../../knowledge/flywheel-loop.js";
+import { WException, getMoveErrorDescription, WErrors } from "@wowok/wowok";
+import { GUARDQUERY } from "@wowok/wowok";
+import { assessGuardRisksForOperation, getRiskSummary } from "../../knowledge/guard-risk.js";
+import { derivePuzzleFromCallData, getPuzzleStatusBooleans, getPendingQuestions, generateConfirmationText, } from "../../knowledge/guard-puzzle.js";
+import { inferSceneFromAction } from "../../knowledge/guard-ledger.js";
+import { matchSemanticPattern } from "../../knowledge/guard-translation.js";
 function booleanFromSignals(positive, negative) {
     if (positive)
         return true;
@@ -13,78 +19,405 @@ function booleanFromSignals(positive, negative) {
 }
 const ERROR_RULES = [
     {
-        patterns: [/insufficient\s*(gas|balance|coin|fund)/i, /ENOTENOUGH/i, /not\s*enough\s*(coin|gas|balance)/i, /gas\s*budget/i],
+        patterns: [
+            /too\s*many\s*requests/i,
+            /rate\s*limit/i,
+            /429/i,
+            /throttl/i,
+            /faucet.*rate/i,
+            /request.*limit.*exceeded/i,
+        ],
+        error_code: "rate_limit",
+        retryable: true,
+        recovery_hint: "Rate limit hit (HTTP 429). Wait with exponential backoff and retry. To check existing balance, use account_balance query.",
+    },
+    {
+        patterns: [
+            /gas.*budget.*exceeded/i,
+            /out\s*of\s*gas/i,
+            /gas\s*exceeded/i,
+            /insufficient\s*gas/i,
+            /not\s*enough\s*gas/i,
+            /could not automatically determine a budget/i,
+            /dry run failed.*budget/i,
+            /Maximum gas/i,
+        ],
+        error_code: "gas_exceeded",
+        retryable: true,
+        recovery_hint: "Gas budget exceeded. Increase the gas_budget parameter or claim more gas tokens, then retry",
+    },
+    {
+        patterns: [
+            /insufficient\s*(balance|coin|fund)/i,
+            /ENOTENOUGH/i,
+            /not\s*enough\s*(coin|balance)/i,
+            /coin\s*not\s*enough/i,
+            /balance\s*not\s*enough/i,
+            /stock\s*not\s*enough/i,
+            /fee\s*not\s*enough/i,
+            /Insufficient balance/i,
+        ],
         error_code: "insufficient_balance",
         retryable: true,
         recovery_hint: "Claim faucet tokens via account_operation (faucet) then retry the call",
     },
     {
-        patterns: [/network/i, /timeout/i, /ECONNRESET/i, /ETIMEDOUT/i, /RPC\s*(error|failed|unreachable)/i, /socket\s*hang\s*up/i, /fetch\s*failed/i],
+        patterns: [
+            /bcs.*(error|fail|invalid)/i,
+            /BCS serialization/i,
+            /serialization\s*(failure|error)/i,
+            /deserialization\s*(failure|error)/i,
+            /invalid bcs type/i,
+            /Out of range.*bcs/i,
+            /Length out of range/i,
+            /parse object content failed/i,
+        ],
+        error_code: "bcs_error",
+        retryable: false,
+        recovery_hint: "BCS serialization/deserialization error. Verify data types and structure match the expected schema",
+    },
+    {
+        patterns: [
+            /signature.*(invalid|fail|error|verif)/i,
+            /invalid\s*signature/i,
+            /signature\s*verification\s*failed/i,
+            /bad\s*signature/i,
+            /signing\s*fail/i,
+            /crypto.*signature/i,
+            /ed25519.*(fail|error|invalid)/i,
+            /secp256k1.*(fail|error|invalid)/i,
+        ],
+        error_code: "signature_error",
+        retryable: false,
+        recovery_hint: "Signature verification failed. Check that the correct private key and network configuration are correct",
+    },
+    {
+        patterns: [
+            /config.*(not set|not found|invalid|missing)/i,
+            /RPC\s*not\s*configured/i,
+            /network.*not\s*specified/i,
+            /protocol network not specified/i,
+            /account persistent storage not set/i,
+            /config persistent storage not set/i,
+            /account persistent storage not found/i,
+            /no\s*rpc\s*url/i,
+        ],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Configuration error. Verify that network, RPC endpoints, and required environment variables are properly configured",
+    },
+    {
+        patterns: [
+            /network/i,
+            /timeout/i,
+            /ECONNRESET/i,
+            /ETIMEDOUT/i,
+            /ECONNREFUSED/i,
+            /EAI_AGAIN/i,
+            /RPC\s*(error|failed|unreachable)/i,
+            /socket\s*hang\s*up/i,
+            /fetch\s*failed/i,
+            /connection\s*(refused|reset|lost)/i,
+            /dns\s*(error|fail)/i,
+        ],
         error_code: "network_error",
         retryable: true,
         recovery_hint: "Retry the call; if it persists, switch RPC endpoint or check connectivity",
     },
     {
-        patterns: [/faucet/i, /too\s*many\s*requests/i, /rate\s*limit/i, /429/i],
-        error_code: "network_error",
-        retryable: true,
-        recovery_hint: "Faucet rate limit hit (HTTP 429). Wait a few minutes and retry. To check existing balance, use account_balance query.",
-    },
-    {
-        patterns: [/guard.*(reject|fail|denied)/i, /verification\s*failed/i, /submission.*(invalid|fail|required)/i, /passport.*(invalid|fail)/i, /move[._-]?abort.*guard/i],
+        patterns: [
+            /guard.*(reject|fail|denied|verif)/i,
+            /verification\s*failed/i,
+            /submission.*(invalid|fail|required)/i,
+            /passport.*(invalid|fail|verif)/i,
+            /move[._-]?abort.*guard/i,
+            /Guard count exceeded limit/i,
+            /Submission size exceeded limit/i,
+            /Submission not found/i,
+            /Guard not found/i,
+            /Impact guard not found/i,
+        ],
         error_code: "guard_rejected",
         retryable: false,
         recovery_hint: "Fill the Guard submission data (see the 'submission' field) and resubmit via call_with_submission",
     },
     {
-        patterns: [/already\s*publish/i, /immutable/i, /cannot\s*(modify|change|mutate)/i, /locked/i, /is\s*published/i],
+        patterns: [
+            /already\s*publish/i,
+            /immutable/i,
+            /cannot\s*(modify|change|mutate)/i,
+            /locked/i,
+            /is\s*published/i,
+            /Service already published/i,
+            /Machine already published/i,
+            /setting lock duration not exceeded/i,
+        ],
         error_code: "immutable_violation",
         retryable: false,
         recovery_hint: "Object is in an immutable state (e.g. Service already published). Recreate the object if a different config is needed",
     },
     {
-        patterns: [/permission/i, /unauthorized/i, /forbidden/i, /not\s*(the\s*)?owner/i, /access\s*denied/i],
+        patterns: [
+            /permission/i,
+            /unauthorized/i,
+            /forbidden/i,
+            /not\s*(the\s*)?owner/i,
+            /access\s*denied/i,
+            /no permission/i,
+            /Permission denied/i,
+            /Not the builder/i,
+            /Not admin/i,
+            /No operation permission/i,
+            /Not the holder/i,
+        ],
         error_code: "permission_denied",
         retryable: false,
         recovery_hint: "Use an account with the required permission, or pass permission_guard IDs via env.permission_guard",
     },
     {
-        patterns: [/not\s*found/i, /does\s*not\s*exist/i, /ENOTFOUND/i, /no\s*such\s*object/i, /unknown\s*object/i],
+        patterns: [
+            /not\s*found/i,
+            /does\s*not\s*exist/i,
+            /ENOTFOUND/i,
+            /no\s*such\s*object/i,
+            /unknown\s*object/i,
+            /account not found/i,
+            /address not found/i,
+            /token not found/i,
+            /Node not found/i,
+            /Policy not found/i,
+            /Reward not found/i,
+        ],
         error_code: "object_not_found",
         retryable: false,
         recovery_hint: "Verify the object ID/name with query_toolkit; local_mark names are case-sensitive",
     },
     {
-        patterns: [/state\s*(conflict|mismatch)/i, /already\s*exist/i, /conflict/i, /duplicate/i, /version\s*mismatch/i],
+        patterns: [
+            /state\s*(conflict|mismatch)/i,
+            /already\s*exist/i,
+            /conflict/i,
+            /duplicate/i,
+            /version\s*mismatch/i,
+            /name exist/i,
+            /Duplicate forward name/i,
+            /Duplicate node previous/i,
+            /already claimed/i,
+            /already specified/i,
+            /already accomplished/i,
+            /already used/i,
+            /Status does not match/i,
+            /does not match/i,
+        ],
         error_code: "state_conflict",
         retryable: false,
         recovery_hint: "Object state conflicts with the operation. Query the current state with query_toolkit and adjust parameters",
     },
     {
-        patterns: [/invalid/i, /missing\s*(field|param|required)/i, /required/i, /expected/i, /malformed/i, /parse\s*error/i, /type\s*mismatch/i],
+        patterns: [
+            /invalid/i,
+            /missing\s*(field|param|required)/i,
+            /required/i,
+            /expected/i,
+            /malformed/i,
+            /parse\s*error/i,
+            /type\s*mismatch/i,
+            /invalid argument/i,
+            /Invalid value/i,
+            /Invalid data value/i,
+            /Invalid string value/i,
+            /Invalid argument/i,
+            /IsValid/i,
+            /type does not match/i,
+            /value type/i,
+        ],
         error_code: "invalid_parameter",
         retryable: false,
         recovery_hint: "Check parameter format against the tool schema; consult wowok-tools Skill for the operation's requirements",
     },
 ];
-export function classifyError(errorMsg) {
+const WERROR_MAPPINGS = [
+    {
+        codes: [WErrors.AccountNotFound, WErrors.AddressNotFound, WErrors.TokenNotFoundLocally],
+        error_code: "object_not_found",
+        retryable: false,
+        recovery_hint: "Verify the object ID/name with query_toolkit; local_mark names are case-sensitive",
+    },
+    {
+        codes: [WErrors.NoPermission],
+        error_code: "permission_denied",
+        retryable: false,
+        recovery_hint: "Use an account with the required permission, or pass permission_guard IDs via env.permission_guard",
+    },
+    {
+        codes: [
+            WErrors.IsValidDescription,
+            WErrors.IsValidName,
+            WErrors.IsValidName_AllowEmpty,
+            WErrors.IsValidEndpoint,
+            WErrors.IsValidAddress,
+            WErrors.IsValidArgType,
+            WErrors.IsValidTokenType,
+            WErrors.IsValidUint,
+            WErrors.IsValidInt,
+            WErrors.IsValidU8,
+            WErrors.IsValidU16,
+            WErrors.IsValidU32,
+            WErrors.IsValidU64,
+            WErrors.IsValidU128,
+            WErrors.IsValidU256,
+            WErrors.IsValidRate,
+            WErrors.IsValidArray,
+            WErrors.IsValidObjects,
+            WErrors.AllInvalid,
+            WErrors.InvalidParam,
+            WErrors.IsValidPermissionIndex,
+            WErrors.IsValidKey,
+            WErrors.IsValidIdentifier,
+            WErrors.IsValidHttpUrl,
+            WErrors.IsValidBizPermissionIndex,
+            WErrors.IsValidServiceItemName,
+            WErrors.IsValidCoinType,
+            WErrors.IsValidGuardIdentifier,
+            WErrors.IsValidValue,
+            WErrors.IsValidValueType,
+            WErrors.IsValidLocation,
+            WErrors.WitnessTypeInvalid,
+        ],
+        error_code: "invalid_parameter",
+        retryable: false,
+        recovery_hint: "Check parameter format against the tool schema; consult wowok-tools Skill for the operation's requirements",
+    },
+    {
+        codes: [WErrors.BcsTypeInvalid, WErrors.ParseObjectContentFailed],
+        error_code: "bcs_error",
+        retryable: false,
+        recovery_hint: "BCS serialization/deserialization error. Verify data types and structure match the expected schema",
+    },
+    {
+        codes: [WErrors.NetworkInvalid],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Configuration error. Verify that network, RPC endpoints, and required environment variables are properly configured",
+    },
+    {
+        codes: [
+            WErrors.AccountPersistentStorageNotSet,
+            WErrors.ConfigPersistentStorageNotSet,
+            WErrors.AccountPersistentStorageNotFound,
+        ],
+        error_code: "config_error",
+        retryable: false,
+        recovery_hint: "Persistent storage not configured. Initialize account storage before performing this operation",
+    },
+    {
+        codes: [WErrors.AccountNameExist, WErrors.LocalMarkNameExist],
+        error_code: "state_conflict",
+        retryable: false,
+        recovery_hint: "Object state conflicts with the operation. Query the current state with query_toolkit and adjust parameters",
+    },
+    {
+        codes: [WErrors.MaxObjectsPerQuery, WErrors.ResourceTagCountExceeded, WErrors.AddressCountExceeded, WErrors.NumberCountExceeded],
+        error_code: "invalid_parameter",
+        retryable: false,
+        recovery_hint: "Count limit exceeded. Reduce the number of items per request and retry",
+    },
+];
+function isWException(value) {
+    return value instanceof WException;
+}
+function classifyWException(exception) {
+    const code = exception.getErrorCode();
+    const mapping = WERROR_MAPPINGS.find((m) => m.codes.includes(code));
+    if (!mapping)
+        return undefined;
+    const result = {
+        error_code: mapping.error_code,
+        retryable: mapping.retryable,
+        recovery_hint: mapping.recovery_hint,
+    };
+    return result;
+}
+const WOWOK_ADDRESSES = new Set([
+    "0x0000000000000000000000000000000000000000000000000000000000000002",
+    "0x2",
+]);
+function extractMoveAbortInfo(errorMsg) {
+    if (!errorMsg)
+        return undefined;
+    const abortCodeMatch = errorMsg.match(/MoveAbort\([^,]+,\s*(\d+)\)/);
+    const moduleNameMatch = errorMsg.match(/name:\s*Identifier\("([^"]+)"\)/);
+    const addressMatch = errorMsg.match(/address:\s*([0-9a-fA-Fx]+)/);
+    if (abortCodeMatch && moduleNameMatch && addressMatch) {
+        const code = parseInt(abortCodeMatch[1], 10);
+        const module = moduleNameMatch[1].toLowerCase();
+        const address = addressMatch[1].toLowerCase();
+        if (WOWOK_ADDRESSES.has(address)) {
+            const description = getMoveErrorDescription(module, code) ?? undefined;
+            return { module, code, description };
+        }
+    }
+    const formattedAbortCode = errorMsg.match(/abort code:\s*(\d+)/);
+    const formattedModule = errorMsg.match(/'0x[0-9a-fA-F]+::([^:]+)::[^']+'/);
+    const formattedAddress = errorMsg.match(/'(0x[0-9a-fA-F]+)::/);
+    if (formattedAbortCode && formattedModule && formattedAddress) {
+        const code = parseInt(formattedAbortCode[1], 10);
+        const module = formattedModule[1].toLowerCase();
+        const address = formattedAddress[1].toLowerCase();
+        if (WOWOK_ADDRESSES.has(address)) {
+            const description = getMoveErrorDescription(module, code) ?? undefined;
+            return { module, code, description };
+        }
+    }
+    return undefined;
+}
+export function classifyError(errorMsg, error) {
+    if (error !== undefined && isWException(error)) {
+        const fromWException = classifyWException(error);
+        if (fromWException) {
+            const abortInfo = extractMoveAbortInfo(errorMsg);
+            if (abortInfo) {
+                fromWException.move_abort_info = abortInfo;
+                if (abortInfo.description && fromWException.recovery_hint && !fromWException.recovery_hint.includes(abortInfo.description)) {
+                    fromWException.recovery_hint = `${fromWException.recovery_hint}. Details: ${abortInfo.description}`;
+                }
+            }
+            return fromWException;
+        }
+    }
     if (!errorMsg) {
         return { error_code: "unknown", retryable: false };
     }
     for (const rule of ERROR_RULES) {
         if (rule.patterns.some((p) => p.test(errorMsg))) {
-            return {
+            const result = {
                 error_code: rule.error_code,
                 retryable: rule.retryable,
                 recovery_hint: rule.recovery_hint,
             };
+            const abortInfo = extractMoveAbortInfo(errorMsg);
+            if (abortInfo) {
+                result.move_abort_info = abortInfo;
+                if (abortInfo.description) {
+                    result.recovery_hint = `${result.recovery_hint}. Details: ${abortInfo.description}`;
+                }
+            }
+            return result;
         }
     }
-    return {
+    const abortInfo = extractMoveAbortInfo(errorMsg);
+    const fallback = {
         error_code: "unknown",
         retryable: false,
         recovery_hint: "Inspect the full error message; consult wowok-tools Skill for the operation's requirements",
     };
+    if (abortInfo) {
+        fallback.move_abort_info = abortInfo;
+        if (abortInfo.description) {
+            fallback.recovery_hint = `${abortInfo.description}. ${fallback.recovery_hint}`;
+        }
+    }
+    return fallback;
 }
 const INTENT_RULES = [
     { operation_type: "service", signals: (d) => d?.publish === true, intent: "publish_service", confidence: 0.95 },
@@ -773,11 +1106,11 @@ function buildCustomerAdvice(operation_type, data, safeResult) {
         if (r.action)
             recommendations.push(r.action);
     }
-    if (noArbitration && !recommendations.some((r) => r.includes("仲裁"))) {
-        recommendations.push("要求商家配置 Arbitration 服务后再下单");
+    if (noArbitration && !recommendations.some((r) => r.includes("arbitration"))) {
+        recommendations.push("Require the merchant to configure an Arbitration service before placing the order");
     }
-    if (noCompensation && !recommendations.some((r) => r.includes("赔偿金"))) {
-        recommendations.push("要求商家设置 compensation_fund（赔偿金）以保障订单失败时自动赔付");
+    if (noCompensation && !recommendations.some((r) => r.includes("compensation"))) {
+        recommendations.push("Require the merchant to set a compensation_fund to guarantee automatic payout when the order fails");
     }
     const advice = {
         recommendations,
@@ -795,6 +1128,256 @@ function buildCustomerAdvice(operation_type, data, safeResult) {
         advice.risk_level = riskLevel;
     return advice;
 }
+function buildGuardAdvice(operation_type, data, safeResult) {
+    try {
+        if (operation_type === "guard") {
+            return buildGuardCreateAdvice(data);
+        }
+        if (operation_type === "gen_passport") {
+            const status = safeResult?.error ? "fail" : "pass";
+            return {
+                current_round: "R8",
+                test_result: {
+                    status: status,
+                    passport_id: status === "pass" ? safeResult?.passport : undefined,
+                    failure_node: status === "fail"
+                        ? (typeof safeResult?.error === "string" ? safeResult.error.slice(0, 120) : undefined)
+                        : undefined,
+                },
+            };
+        }
+        const errorStr = typeof safeResult?.error === "string" ? safeResult.error : "";
+        if (errorStr.includes("GUARD") || errorStr.includes("Guard") || errorStr.includes("guard")) {
+            return {
+                risk_warnings: [
+                    `Guard verification failed: ${errorStr.slice(0, 200)}`,
+                    "Suggestion: check whether the submission data matches the Guard table declaration, or query the Guard definition to learn the required submission",
+                ],
+            };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildGuardCreateAdvice(data) {
+    if (!data)
+        return undefined;
+    const puzzleInput = convertCallDataToPuzzleInput(data);
+    const puzzle = derivePuzzleFromCallData(puzzleInput);
+    const puzzleStatusBooleans = getPuzzleStatusBooleans(puzzle);
+    let matchedScene;
+    let sceneDescription;
+    let sceneConstraints;
+    if (data.binding_hint?.action) {
+        matchedScene = inferSceneFromAction(data.binding_hint.action);
+        if (matchedScene) {
+            sceneDescription = matchedScene.name;
+            sceneConstraints = matchedScene.special_constraints;
+        }
+    }
+    let suggestedPatterns;
+    const intentText = data.binding_hint?.rule_sentence
+        || data.binding_hint?.action
+        || "";
+    if (intentText) {
+        const matched = matchSemanticPattern(intentText);
+        if (matched.length > 0) {
+            suggestedPatterns = matched.map((m) => `${m.id}: ${m.pattern_name}`);
+        }
+    }
+    let confirmationText;
+    try {
+        const text = generateConfirmationText(puzzle);
+        if (!text.startsWith("[Puzzle incomplete]")) {
+            confirmationText = text;
+        }
+    }
+    catch {
+    }
+    let pendingQuestions;
+    const pendingQs = getPendingQuestions(puzzle);
+    if (pendingQs.length > 0) {
+        pendingQuestions = pendingQs;
+    }
+    let availableQueries;
+    if (matchedScene) {
+        const sceneObjectType = mapSceneToObjectType(matchedScene);
+        if (sceneObjectType) {
+            const filtered = GUARDQUERY
+                .filter((q) => q.objectType === sceneObjectType)
+                .slice(0, 10)
+                .map((q) => ({
+                id: q.id,
+                name: q.name,
+                objectType: String(q.objectType),
+                returnType: String(q.return),
+                description: q.description,
+            }));
+            if (filtered.length > 0) {
+                availableQueries = filtered;
+            }
+        }
+    }
+    const assessment = assessGuardRisksForOperation("guard", data);
+    let riskAssessment;
+    let riskWarnings;
+    if (assessment) {
+        const summary = getRiskSummary(assessment);
+        riskAssessment = {
+            overall_risk: summary.risk_count > 0 ? assessment.overall_risk : "info",
+            risk_count: summary.risk_count,
+            critical_count: summary.critical_count,
+            high_count: summary.high_count,
+            needs_human_review: summary.needs_human_review,
+            top_risks: summary.top_risks,
+            stakeholder_advice: assessment.stakeholder_advice,
+        };
+        const warnings = assessment.risks.map((r) => `[${r.level.toUpperCase()}] ${r.title}: ${r.description}`);
+        if (warnings.length > 0) {
+            riskWarnings = warnings;
+        }
+    }
+    const advice = {
+        current_round: "R7",
+        puzzle_status: puzzleStatusBooleans,
+    };
+    if (matchedScene)
+        advice.matched_scene = matchedScene.id;
+    if (sceneDescription)
+        advice.scene_description = sceneDescription;
+    if (sceneConstraints)
+        advice.scene_constraints = sceneConstraints;
+    if (suggestedPatterns)
+        advice.suggested_patterns = suggestedPatterns;
+    if (availableQueries)
+        advice.available_queries = availableQueries;
+    if (riskWarnings)
+        advice.risk_warnings = riskWarnings;
+    if (pendingQuestions)
+        advice.pending_questions = pendingQuestions;
+    if (confirmationText)
+        advice.confirmation_text = confirmationText;
+    if (riskAssessment)
+        advice.risk_assessment = riskAssessment;
+    return advice;
+}
+function convertCallDataToPuzzleInput(data) {
+    const result = {};
+    if (Array.isArray(data.table)) {
+        result.table = data.table.map((item) => ({
+            identifier: item.identifier,
+            b_submission: item.b_submission,
+            value_type: typeof item.value_type === "string" ? item.value_type : String(item.value_type),
+            value: convertValueSnapshot(item.value),
+            name: item.name ?? "",
+            object_type: item.object_type,
+        }));
+    }
+    if (data.root && typeof data.root === "object") {
+        const rootObj = data.root;
+        if (rootObj.type !== "file" && rootObj.type !== "node") {
+            result.root = convertNodeToSnapshot(data.root);
+        }
+        else if (rootObj.type === "node" && data.root.node) {
+            result.root = convertNodeToSnapshot(data.root.node);
+        }
+    }
+    if (data.rely && Array.isArray(data.rely.guards)) {
+        result.rely = {
+            guards: data.rely.guards.map((g) => typeof g === "string" ? g : String(g)),
+            logic_or: data.rely.logic_or,
+        };
+    }
+    if (data.binding_hint) {
+        const bh = data.binding_hint;
+        const bindingHint = {
+            action: bh.action,
+            host_object: bh.host_object,
+            binding_field: bh.binding_field,
+        };
+        if (bh.rule_sentence !== undefined)
+            bindingHint.rule_sentence = bh.rule_sentence;
+        if (bh.failure_conditions !== undefined)
+            bindingHint.failure_conditions = bh.failure_conditions;
+        if (bh.circular_reference !== undefined)
+            bindingHint.circular_reference = bh.circular_reference;
+        result.binding_hint = bindingHint;
+    }
+    return result;
+}
+function convertNodeToSnapshot(node) {
+    if (!node || typeof node !== "object") {
+        return { type: "unknown" };
+    }
+    const snapshot = {
+        type: String(node.type ?? "unknown"),
+    };
+    if (typeof node.identifier === "number") {
+        snapshot.identifier = node.identifier;
+    }
+    if (node.query !== undefined) {
+        snapshot.query = typeof node.query === "number" ? node.query : String(node.query);
+    }
+    if (node.object && typeof node.object === "object") {
+        const obj = {
+            identifier: Number(node.object.identifier),
+        };
+        if (typeof node.object.convert_witness === "number") {
+            obj.convert_witness = node.object.convert_witness;
+        }
+        snapshot.object = obj;
+    }
+    if (Array.isArray(node.parameters)) {
+        snapshot.parameters = node.parameters.map((p) => convertNodeToSnapshot(p));
+    }
+    if (typeof node.context === "string") {
+        const ctxValue = node.context;
+        if (ctxValue === "Clock" || ctxValue === "Guard" || ctxValue === "Signer") {
+            snapshot.context = ctxValue;
+        }
+    }
+    if (Array.isArray(node.nodes)) {
+        snapshot.nodes = node.nodes.map((n) => convertNodeToSnapshot(n));
+    }
+    if (node.node) {
+        snapshot.node = convertNodeToSnapshot(node.node);
+    }
+    if (node.nodeLeft) {
+        snapshot.nodeLeft = convertNodeToSnapshot(node.nodeLeft);
+    }
+    if (node.nodeRight) {
+        snapshot.nodeRight = convertNodeToSnapshot(node.nodeRight);
+    }
+    return snapshot;
+}
+function convertValueSnapshot(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const allString = value.every((v) => typeof v === "string");
+        if (allString)
+            return value;
+        const allNumber = value.every((v) => typeof v === "number");
+        if (allNumber)
+            return value;
+        const allBool = value.every((v) => typeof v === "boolean");
+        if (allBool)
+            return value;
+        return JSON.stringify(value);
+    }
+    return JSON.stringify(value);
+}
+function mapSceneToObjectType(scene) {
+    const hostObject = scene.host_object;
+    if (hostObject === "Standalone")
+        return undefined;
+    return hostObject;
+}
 export function buildSemantic(safeResult, context) {
     if (!context)
         return undefined;
@@ -820,7 +1403,8 @@ export function buildSemantic(safeResult, context) {
         }
     }
     let experience;
-    if (isRuntimeEnabled("experience_layer")) {
+    const experienceLayerEnabled = isRuntimeEnabled("experience_layer");
+    if (experienceLayerEnabled) {
         try {
             const feedback = getExperienceFeedback(context.operation_type, context.data, intent);
             if (feedback) {
@@ -828,7 +1412,8 @@ export function buildSemantic(safeResult, context) {
             }
             const outcome = status === "success" ? "success" : status === "failed" ? "failed" : "partial";
             const referencedObjects = [...created, ...modified].map((o) => o.id).filter(Boolean);
-            recordOperationOutcome(context.operation_type, context.data, intent, outcome, undefined, referencedObjects);
+            const errCode = inferErrorCodeForSignal(safeResult);
+            recordOperationOutcome(context.operation_type, context.data, intent, outcome, errCode, referencedObjects);
         }
         catch {
         }
@@ -839,7 +1424,7 @@ export function buildSemantic(safeResult, context) {
             const industryHint = (typeof context.data?.industry === "string" && context.data.industry.trim())
                 ? context.data.industry.trim()
                 : undefined;
-            if (industryHint) {
+            if (industryHint && !experienceLayerEnabled) {
                 const outcome = status === "success"
                     ? { success: true }
                     : { success: false, error_code: inferErrorCodeForSignal(safeResult) };
@@ -875,6 +1460,12 @@ export function buildSemantic(safeResult, context) {
     }
     catch {
     }
+    let guard_advice;
+    try {
+        guard_advice = buildGuardAdvice(context.operation_type, context.data, safeResult);
+    }
+    catch {
+    }
     return {
         intent,
         status,
@@ -889,6 +1480,7 @@ export function buildSemantic(safeResult, context) {
         service_status,
         customer_advice,
         evolution_context,
+        guard_advice,
     };
 }
 function inferErrorCodeForSignal(safeResult) {