@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/schema/call/semantic.js

@@ -1,71 +1,419 @@
+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/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 { assessGuardRisksForOperation, getRiskSummary } from "../../knowledge/guard-risk.js";
+function booleanFromSignals(positive, negative) {
+    if (positive)
+        return true;
+    if (negative)
+        return false;
+    return undefined;
+}
 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: [/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 },
@@ -553,6 +901,13 @@ const NEXT_ACTION_RULES = [
         reason: "Order lifecycle: payment → allocation → completion",
         priority: "optional",
     },
+    {
+        when: (ot, data) => ot === "order" && data?.transfer_to !== undefined,
+        action: "inform the end customer about the supplier/sub-contractor who will fulfill this order",
+        reason: "O-5 procurement sub-order transparency: customers have the right to know who fulfills their order",
+        tool: "messenger_operation (notify customer)",
+        priority: "recommended",
+    },
     {
         when: (ot) => ot === "demand",
         action: "wait for presenter submissions or evaluate existing ones",
@@ -633,6 +988,10 @@ function inferWarnings(operation_type, data, _safeResult) {
     if (operation_type === "reward" && (data?.balance === "0" || data?.balance === 0)) {
         warnings.push("Reward pool balance is zero; claimants cannot withdraw");
     }
+    if (operation_type === "order" && data?.transfer_to !== undefined) {
+        warnings.push("[TRANSPARENCY] Order ownership is being transferred (likely to a supplier/sub-contractor). " +
+            "Ensure the end customer is informed about who fulfills their order — this builds trust and is required for procurement sub-orders.");
+    }
     return warnings;
 }
 function composeSummary(intent, status, created, modified, released) {
@@ -679,6 +1038,142 @@ function shortCoinType(coinType) {
     const parts = coinType.split("::");
     return parts[parts.length - 1] || coinType;
 }
+function buildCustomerAdvice(operation_type, data, safeResult) {
+    if (!isRuntimeEnabled("customer_intelligence"))
+        return undefined;
+    let stage;
+    if (operation_type === "order") {
+        stage = "preorder";
+    }
+    else if (operation_type === "query_toolkit" || operation_type === "onchain_table_data" || operation_type === "onchain_events") {
+        stage = "browse";
+    }
+    else if (operation_type === "service") {
+        stage = "evaluate";
+    }
+    else {
+        return undefined;
+    }
+    const serviceId = data?.service_name ?? data?.service_id ?? data?.service ?? data?.name;
+    const orderId = data?.order_name ?? data?.order_id ?? data?.order;
+    let servicePrice;
+    if (data?.price !== undefined) {
+        try {
+            servicePrice = BigInt(String(data.price));
+        }
+        catch { }
+    }
+    if (servicePrice === undefined && safeResult?.price !== undefined) {
+        try {
+            servicePrice = BigInt(String(safeResult.price));
+        }
+        catch { }
+    }
+    const hasArbitration = booleanFromSignals(data?.arb_name !== undefined || data?.arbitration !== undefined, data?.arb === false);
+    const hasCompensation = booleanFromSignals(data?.compensation_fund !== undefined || data?.compensation !== undefined, false);
+    const hasRefundPath = booleanFromSignals(data?.refund !== undefined, false);
+    const hasMessenger = booleanFromSignals(data?.um_name !== undefined || data?.messenger !== undefined, false);
+    const noArbitration = hasArbitration === false;
+    const noCompensation = hasCompensation === false;
+    const riskScore = typeof data?.risk_score === "number" ? data.risk_score
+        : typeof safeResult?.risk_score === "number" ? safeResult.risk_score : undefined;
+    const riskLevel = data?.risk_level ?? safeResult?.risk_level;
+    const profile = getProfile();
+    const userMinTrust = profile.risk_appetite === "conservative" ? 70
+        : profile.risk_appetite === "aggressive" ? 30 : 50;
+    const ctx = {
+        stage,
+        service_id: serviceId,
+        order_id: orderId,
+        service_price: servicePrice,
+        has_arbitration: hasArbitration,
+        has_compensation: hasCompensation,
+        has_refund_path: hasRefundPath,
+        has_messenger: hasMessenger,
+        risk_score: riskScore,
+        risk_level: riskLevel,
+        user_min_trust_score: userMinTrust,
+        user_require_arbitration: profile.risk_appetite === "conservative",
+        user_require_compensation: profile.risk_appetite === "conservative",
+    };
+    const reminders = generateReminders(ctx);
+    const recommendations = [];
+    for (const r of reminders) {
+        if (r.action)
+            recommendations.push(r.action);
+    }
+    if (noArbitration && !recommendations.some((r) => r.includes("仲裁"))) {
+        recommendations.push("要求商家配置 Arbitration 服务后再下单");
+    }
+    if (noCompensation && !recommendations.some((r) => r.includes("赔偿金"))) {
+        recommendations.push("要求商家设置 compensation_fund（赔偿金）以保障订单失败时自动赔付");
+    }
+    const advice = {
+        recommendations,
+        reminders: reminders.map((r) => ({
+            id: r.id,
+            stage: r.stage,
+            priority: r.priority,
+            message: r.message,
+            action: r.action,
+        })),
+    };
+    if (riskScore !== undefined)
+        advice.risk_score = riskScore;
+    if (riskLevel !== undefined)
+        advice.risk_level = riskLevel;
+    return advice;
+}
+function buildGuardAdvice(operation_type, data, safeResult) {
+    try {
+        if (operation_type === "guard") {
+            const assessment = assessGuardRisksForOperation(operation_type, data);
+            if (assessment) {
+                const summary = getRiskSummary(assessment);
+                const riskWarnings = assessment.risks.map((r) => `[${r.level.toUpperCase()}] ${r.title}: ${r.description}`);
+                return {
+                    current_round: "R7",
+                    risk_assessment: {
+                        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,
+                    },
+                    risk_warnings: riskWarnings.length > 0 ? riskWarnings : undefined,
+                };
+            }
+        }
+        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 验证失败: ${errorStr.slice(0, 200)}`,
+                    "建议: 检查提交数据是否符合 Guard table 声明，或查询 Guard 定义了解所需 submission",
+                ],
+            };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildSemantic(safeResult, context) {
     if (!context)
         return undefined;
@@ -693,6 +1188,80 @@ export function buildSemantic(safeResult, context) {
     const annotatedEvents = annotateEvents(events);
     const next_actions = inferNextActions(context.operation_type, context.data, status);
     const warnings = inferWarnings(context.operation_type, context.data, safeResult);
+    if (context.pre_warnings && context.pre_warnings.length > 0) {
+        warnings.push(...context.pre_warnings);
+    }
+    if (context.operation_type === "service" && context.data?.publish === true) {
+        const findings = auditService(context.data);
+        for (const f of findings) {
+            const prefix = f.severity === "error" ? "[AUDIT ERROR] " : f.severity === "warning" ? "[AUDIT] " : "[INFO] ";
+            warnings.push(prefix + f.message);
+        }
+    }
+    let experience;
+    const experienceLayerEnabled = isRuntimeEnabled("experience_layer");
+    if (experienceLayerEnabled) {
+        try {
+            const feedback = getExperienceFeedback(context.operation_type, context.data, intent);
+            if (feedback) {
+                experience = feedback;
+            }
+            const outcome = status === "success" ? "success" : status === "failed" ? "failed" : "partial";
+            const referencedObjects = [...created, ...modified].map((o) => o.id).filter(Boolean);
+            const errCode = inferErrorCodeForSignal(safeResult);
+            recordOperationOutcome(context.operation_type, context.data, intent, outcome, errCode, referencedObjects);
+        }
+        catch {
+        }
+    }
+    let evolution_context;
+    if (isRuntimeEnabled("industry_evolution")) {
+        try {
+            const industryHint = (typeof context.data?.industry === "string" && context.data.industry.trim())
+                ? context.data.industry.trim()
+                : undefined;
+            if (industryHint && !experienceLayerEnabled) {
+                const outcome = status === "success"
+                    ? { success: true }
+                    : { success: false, error_code: inferErrorCodeForSignal(safeResult) };
+                recordIndustrySignal(industryHint, { type: context.operation_type, data: context.data }, outcome);
+            }
+            if (industryHint) {
+                const evoCtx = injectEvolutionContext(undefined, industryHint);
+                if (evoCtx && (evoCtx.industry_signal || evoCtx.evolution_advice || evoCtx.confidence > 0)) {
+                    evolution_context = evoCtx;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    let service_status;
+    if (isRuntimeEnabled("semantic_rich")) {
+        try {
+            const all = listServices();
+            const active = all.filter((s) => s.enabled).map((s) => s.name);
+            const inactive = all.filter((s) => !s.enabled).map((s) => s.name);
+            service_status = {
+                active,
+                inactive: inactive.length ? inactive : undefined,
+            };
+        }
+        catch {
+        }
+    }
+    let customer_advice;
+    try {
+        customer_advice = buildCustomerAdvice(context.operation_type, context.data, safeResult);
+    }
+    catch {
+    }
+    let guard_advice;
+    try {
+        guard_advice = buildGuardAdvice(context.operation_type, context.data, safeResult);
+    }
+    catch {
+    }
     return {
         intent,
         status,
@@ -703,8 +1272,20 @@ export function buildSemantic(safeResult, context) {
         events: annotatedEvents.length ? annotatedEvents : undefined,
         next_actions: next_actions.length ? next_actions : undefined,
         warnings: warnings.length ? warnings : undefined,
+        experience,
+        service_status,
+        customer_advice,
+        evolution_context,
+        guard_advice,
     };
 }
+function inferErrorCodeForSignal(safeResult) {
+    if (!safeResult)
+        return undefined;
+    if (typeof safeResult.error === "string")
+        return safeResult.error.slice(0, 64);
+    return undefined;
+}
 export function buildDataSemantic(data, context, isError, errorMsg) {
     if (!context)
         return undefined;
@@ -753,6 +1334,28 @@ export function buildDataSemantic(data, context, isError, errorMsg) {
     else {
         summary = `Successfully ${intentVerb}`;
     }
+    let service_status;
+    if (isRuntimeEnabled("semantic_rich")) {
+        try {
+            const all = listServices();
+            const active = all.filter((s) => s.enabled).map((s) => s.name);
+            const inactive = all.filter((s) => !s.enabled).map((s) => s.name);
+            service_status = {
+                active,
+                inactive: inactive.length ? inactive : undefined,
+            };
+        }
+        catch {
+        }
+    }
+    let customer_advice;
+    if (!isError) {
+        try {
+            customer_advice = buildCustomerAdvice(context.operation_type, context.data, data);
+        }
+        catch {
+        }
+    }
     return {
         intent,
         status,
@@ -760,5 +1363,7 @@ export function buildDataSemantic(data, context, isError, errorMsg) {
         events: annotatedEvents,
         next_actions: next_actions.length ? next_actions : undefined,
         warnings: warnings.length ? warnings : undefined,
+        service_status,
+        customer_advice,
     };
 }