@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/knowledge/template-registry.js

@@ -0,0 +1,341 @@
+import { GUARD_TEMPLATES, fillGuardTemplate, } from "./guard-templates.js";
+import { MACHINE_TEMPLATES, fillTemplate as fillMachineTemplate, } from "./machine-templates.js";
+import { SERVICE_TEMPLATES, fillServiceTemplate, } from "./service-templates.js";
+import { ORDER_TEMPLATES, fillTemplate as fillOrderTemplate, } from "./order-templates.js";
+import { PROGRESS_TEMPLATES, fillProgressTemplate, } from "./progress-templates.js";
+import { ARBITRATION_TEMPLATES, fillTemplate as fillArbitrationTemplate, } from "./arbitration-templates.js";
+import { TREASURY_TEMPLATES, fillTemplate as fillTreasuryTemplate, } from "./treasury-templates.js";
+import { PERMISSION_TEMPLATES, fillTemplate as fillPermissionTemplate, } from "./permission-templates.js";
+import { PASSPORT_TEMPLATES, fillTemplate as fillPassportTemplate, } from "./passport-templates.js";
+import { ALLOCATION_TEMPLATES, fillTemplate as fillAllocationTemplate, } from "./allocation-templates.js";
+import { REWARD_TEMPLATES, } from "./reward-templates.js";
+export const TEMPLATE_REGISTRY_VERSION = 1;
+export const TEMPLATE_OBJECT_TYPES = [
+    "guard",
+    "machine",
+    "service",
+    "order",
+    "progress",
+    "arbitration",
+    "treasury",
+    "permission",
+    "passport",
+    "allocation",
+    "reward",
+];
+function normalizeParam(p) {
+    return {
+        name: p.name,
+        type: p.type,
+        description: p.description ?? "",
+        required: p.required,
+        ...(p.default !== undefined ? { default: p.default } : {}),
+        ...(p.constraint !== undefined ? { constraint: p.constraint } : {}),
+    };
+}
+function guardMeta(t) {
+    return {
+        id: t.id,
+        object_type: "guard",
+        name: t.name,
+        description: t.description,
+        scenes: [t.scene_id],
+        industries: t.applicable_industries,
+        instantiable: true,
+        parameters: t.parameters.map((p) => normalizeParam(p)),
+    };
+}
+function machineMeta(t) {
+    return {
+        id: t.id,
+        object_type: "machine",
+        name: t.name,
+        description: t.description,
+        scenes: [t.scene_id],
+        industries: t.applicable_industries,
+        instantiable: true,
+        parameters: t.parameters.map((p) => normalizeParam(p)),
+    };
+}
+function bodyMeta(t, objectType, scenes, industries) {
+    return {
+        id: t.id,
+        object_type: objectType,
+        name: t.name,
+        description: t.description,
+        scenes,
+        industries,
+        instantiable: true,
+        parameters: t.params.map((p) => normalizeParam(p)),
+    };
+}
+function rewardMeta(t) {
+    return {
+        id: t.type,
+        object_type: "reward",
+        name: t.name,
+        description: t.description,
+        scenes: [],
+        industries: [],
+        instantiable: false,
+        parameters: t.parameters.map((p) => normalizeParam(p)),
+    };
+}
+let REGISTRY = null;
+let ID_COLLISIONS = [];
+function buildRegistry() {
+    const map = new Map();
+    const collisions = [];
+    const add = (entry) => {
+        if (map.has(entry.meta.id)) {
+            collisions.push(entry.meta.id);
+            return;
+        }
+        map.set(entry.meta.id, entry);
+    };
+    for (const t of GUARD_TEMPLATES) {
+        add({ meta: guardMeta(t), raw: t, notes: t.creation_notes });
+    }
+    for (const t of MACHINE_TEMPLATES) {
+        add({ meta: machineMeta(t), raw: t, notes: t.creation_notes });
+    }
+    for (const t of SERVICE_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "service", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of ORDER_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "order", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of PROGRESS_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "progress", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of ARBITRATION_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "arbitration", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of TREASURY_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "treasury", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of PERMISSION_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "permission", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of PASSPORT_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "passport", t.applicable_scenarios, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of ALLOCATION_TEMPLATES) {
+        add({
+            meta: bodyMeta(t, "allocation", t.applicable_scenes, t.industry_tags),
+            raw: t,
+            notes: t.notes,
+        });
+    }
+    for (const t of REWARD_TEMPLATES) {
+        add({
+            meta: rewardMeta(t),
+            raw: t,
+            guidance: {
+                guardCondition: t.guardCondition,
+                amountRange: t.amountRange,
+                allocationStrategy: t.allocationStrategy,
+                example: t.example,
+                relevantGuardOps: t.relevantGuardOps,
+            },
+        });
+    }
+    ID_COLLISIONS = collisions;
+    return map;
+}
+function registry() {
+    if (!REGISTRY) {
+        REGISTRY = buildRegistry();
+    }
+    return REGISTRY;
+}
+export function getTemplateIdCollisions() {
+    registry();
+    return ID_COLLISIONS;
+}
+export function getTemplateCounts() {
+    const counts = Object.fromEntries(TEMPLATE_OBJECT_TYPES.map((t) => [t, 0]));
+    for (const entry of registry().values()) {
+        counts[entry.meta.object_type] += 1;
+    }
+    return counts;
+}
+export function listTemplates(objectType) {
+    const all = [...registry().values()].map((e) => e.meta);
+    return objectType ? all.filter((m) => m.object_type === objectType) : all;
+}
+export function getTemplateDetail(templateId) {
+    const entry = registry().get(templateId);
+    if (!entry)
+        return null;
+    return {
+        ...entry.meta,
+        raw: entry.raw,
+        ...(entry.notes ? { notes: entry.notes } : {}),
+        ...(entry.guidance ? { guidance: entry.guidance } : {}),
+    };
+}
+export function findTemplateObjectType(templateId) {
+    return registry().get(templateId)?.meta.object_type ?? null;
+}
+export function instantiateTemplate(templateId, params) {
+    const entry = registry().get(templateId);
+    if (!entry) {
+        return {
+            ok: false,
+            object_type: null,
+            template_id: templateId,
+            error: `Template not found: ${templateId}. Use get_templates without 'template' to list all template ids.`,
+        };
+    }
+    const objectType = entry.meta.object_type;
+    if (!entry.meta.instantiable) {
+        return {
+            ok: false,
+            object_type: objectType,
+            template_id: templateId,
+            error: "Reward templates are guidance-only (prose guard conditions) and cannot be " +
+                "instantiated into executable JSON. Use the guidance payload to design the " +
+                "Reward + Guard manually.",
+            guidance: entry.guidance,
+        };
+    }
+    switch (objectType) {
+        case "guard": {
+            const r = fillGuardTemplate(templateId, params);
+            if (!r.ok) {
+                return {
+                    ok: false,
+                    object_type: objectType,
+                    template_id: templateId,
+                    error: r.error,
+                    ...(r.missing ? { missing_params: r.missing } : {}),
+                };
+            }
+            return {
+                ok: true,
+                object_type: objectType,
+                template_id: templateId,
+                body: { table: r.table, root: r.root },
+                ...(entry.notes ? { notes: entry.notes } : {}),
+            };
+        }
+        case "machine": {
+            const r = fillMachineTemplate(templateId, params);
+            if (!r.success) {
+                return {
+                    ok: false,
+                    object_type: objectType,
+                    template_id: templateId,
+                    error: r.validation_errors?.join("; ") ?? "Machine template fill failed",
+                    ...(r.missing_params ? { missing_params: r.missing_params } : {}),
+                };
+            }
+            return {
+                ok: true,
+                object_type: objectType,
+                template_id: templateId,
+                body: { nodes: r.filled_nodes, pairs: r.filled_pairs },
+                ...(entry.notes ? { notes: entry.notes } : {}),
+            };
+        }
+        case "service": {
+            const r = fillServiceTemplate(templateId, params);
+            if (!r.ok) {
+                return {
+                    ok: false,
+                    object_type: objectType,
+                    template_id: templateId,
+                    error: r.error ?? "Service template fill failed",
+                    ...(r.missing_required ? { missing_params: r.missing_required } : {}),
+                };
+            }
+            return {
+                ok: true,
+                object_type: objectType,
+                template_id: templateId,
+                body: r.body,
+                ...(entry.notes ? { notes: entry.notes } : {}),
+            };
+        }
+        case "order":
+        case "arbitration":
+        case "treasury":
+        case "permission":
+        case "passport":
+        case "allocation":
+        case "progress": {
+            const r = fillBodyTemplate(objectType, templateId, params);
+            if (!r.ok) {
+                return {
+                    ok: false,
+                    object_type: objectType,
+                    template_id: templateId,
+                    error: r.error,
+                };
+            }
+            return {
+                ok: true,
+                object_type: objectType,
+                template_id: templateId,
+                body: r.body,
+                ...(entry.notes ? { notes: entry.notes } : {}),
+            };
+        }
+        default:
+            return {
+                ok: false,
+                object_type: objectType,
+                template_id: templateId,
+                error: `Instantiation not supported for object_type '${objectType}'`,
+            };
+    }
+}
+function fillBodyTemplate(objectType, templateId, params) {
+    switch (objectType) {
+        case "order":
+            return fillOrderTemplate(templateId, params);
+        case "arbitration":
+            return fillArbitrationTemplate(templateId, params);
+        case "treasury":
+            return fillTreasuryTemplate(templateId, params);
+        case "permission":
+            return fillPermissionTemplate(templateId, params);
+        case "passport":
+            return fillPassportTemplate(templateId, params);
+        case "allocation":
+            return fillAllocationTemplate(templateId, params);
+        case "progress":
+            return fillProgressTemplate(templateId, params);
+        default:
+            return { ok: false, error: `No body-template fill for '${objectType}'` };
+    }
+}

package/dist/knowledge/tool-constraints.js

@@ -48,17 +48,17 @@ export const TOOL_CONSTRAINTS = [
         constraints: [
             {
                 field: "revenue",
-                description: "Payment requires at least one revenue entry",
+                description: "Payment requires at least one revenue entry (CREATE mode only)",
                 severity: "error",
-                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0,
-                message: () => "Payment requires a non-empty 'revenue' array (payment recipients and amounts).",
+                check: (d) => d?.receive === true || (Array.isArray(d?.revenue) && d.revenue.length > 0),
+                message: () => "Payment requires a non-empty 'revenue' array (payment recipients and amounts). For RECEIVE mode (unwrap CoinWrapper), use {object: '<coinwrapper_id>', receive: true, type_parameter: '0x2::wow::WOW'}.",
             },
             {
                 field: "revenue[0].amount",
-                description: "Payment revenue amount must be specified",
+                description: "Payment revenue amount must be specified (CREATE mode only)",
                 severity: "error",
-                check: (d) => Array.isArray(d?.revenue) && d.revenue.length > 0 &&
-                    (!!d.revenue[0]?.amount?.balance || !!d.revenue[0]?.amount?.coin),
+                check: (d) => d?.receive === true || (Array.isArray(d?.revenue) && d.revenue.length > 0 &&
+                    (!!d.revenue[0]?.amount?.balance || !!d.revenue[0]?.amount?.coin)),
                 message: () => "Payment revenue[0].amount must specify either 'balance' value or 'coin' object (see CoinParamSchema).",
             },
         ],

package/dist/knowledge/tools-reference.js

@@ -87,15 +87,15 @@ export const TOOLS_REFERENCE = [
     },
     {
         name: "wowok_buildin_info",
-        summary: "Protocol info — constants, built-in permissions, guard instructions, network, value types, bridge tokens.",
-        actions: ["constants", "permissions", "guard", "network", "value_types", "bridge_tokens"],
-        notes: ["Read-only — authoritative protocol reference."],
+        summary: "Protocol info — constants, built-in permissions, common mistakes, guard instructions, network, value types, bridge tokens.",
+        actions: ["constants", "built-in permissions", "common mistakes", "guard instructions", "current network", "value types", "mainnet bridge tokens"],
+        notes: ["Read-only — authoritative protocol reference.", "Use 'common mistakes' before submitting an operation to learn known field-name/unit/workflow pitfalls."],
     },
     {
         name: "schema_query",
-        summary: "Look up JSON Schemas for MCP tools and on-chain operations — the authoritative reference.",
-        actions: ["list", "get", "get_output", "search", "list_operations"],
-        notes: ["Always check schema before calling an unfamiliar tool."],
+        summary: "Look up JSON Schemas for MCP tools and on-chain operations — the authoritative reference. Also serves sunk knowledge: tool reference, Guard design patterns, safety rules.",
+        actions: ["list", "get", "get_output", "get_field", "search", "list_operations", "get_guard_templates", "search_examples", "get_tool_reference", "get_guard_design_patterns", "get_safety_rules"],
+        notes: ["Always check schema before calling an unfamiliar tool.", "get_field takes a dot-path (field_path) for single-field lookup; search_examples finds verified example files by keyword.", "get_tool_reference/get_guard_design_patterns/get_safety_rules expose the knowledge sunk from the wowok-tools/guard/safety skills — no skills installation required."],
     },
     {
         name: "bridge_operation",
@@ -105,12 +105,15 @@ export const TOOLS_REFERENCE = [
     },
     {
         name: "project_operation",
-        summary: "Project entity management (SQLite) + 3-pathway graph construction + dual rule-based/LLM-assisted evaluation engine.",
-        actions: ["list_projects", "create_project", "create_project_from_onchain", "update_project", "get_project_detail", "add_object", "remove_object", "create_version", "build_graph", "get_graph", "evaluate_project", "save_evaluation", "compare_projects", "refresh_objects", "get_object_diff", "assemble_context"],
+        summary: "Project entity management (SQLite) + 3-pathway graph construction + dual rule-based/LLM-assisted evaluation engine + industry mode recommendation/registry + C1-C4 intent/risk/substep pipeline.",
+        actions: ["list_projects", "create_project", "create_project_from_onchain", "update_project", "get_project_detail", "add_object", "remove_object", "create_version", "build_graph", "get_graph", "evaluate_project", "save_evaluation", "compare_projects", "refresh_objects", "get_object_diff", "assemble_context", "recommend_industry", "list_modes", "derive_user_mode", "evolve_user_mode", "register_user_mode", "unregister_user_mode", "register_custom_metric", "register_custom_constraint", "list_metrics_constraints", "analyze_intent", "aggregate_risks", "trace_substeps"],
         notes: [
             "GLM6: Projects are first-class entities with SQLite persistence, rigid project-object relationships.",
             "Evaluation: risk/trust/completeness are rule-based (computed locally). value/worth_buying require LLM assistance (returns a prompt).",
             "Graph: 3 pathways — internal references (configurable depth), Registrar inbound (O(1)), potential relationships.",
+            "E.7: call recommend_industry BEFORE create_project when the user describes a business without naming an industry — returns top-3 industries + reference examples.",
+            "E.2: user modes — derive_user_mode customizes a builtin mode; register_user_mode registers fully custom; R-M1-11 enforced on machine_shape.",
+            "C1-C4 pipeline (GLM5-31 §V3/V4): analyze_intent (intent → objects + puzzle snapshots) → aggregate_risks (puzzles OR intent → calibrated risks + RISK_BLOCKED status; optional planned_objects/planned_operations safety checks) → trace_substeps (substep records → DAG coherence + D-10 verdict). All three are pure transformations — no I/O, no confirmation needed.",
         ],
     },
     {

package/dist/participation/merchant-interest.d.ts

@@ -0,0 +1,32 @@
+import type { RadarForward } from "./radar-core.js";
+export interface MerchantInterestInput {
+    account: string;
+    current_node: string;
+    operable: RadarForward[];
+    waiting_on: Array<{
+        role: string;
+        forwards: string[];
+    }>;
+    order_amount?: string;
+    token_type?: string;
+    allocation?: {
+        recipient_slots: number;
+        guard_gated_slots: number;
+        direct_to_me_slots: number;
+        to_payer_slots: number;
+    };
+    compensation_fund?: string;
+    arbitration_bound: boolean;
+    rewards_count: number;
+    stalled_hours?: number;
+    terminal?: "completed" | "refunded" | null;
+    unread_messages?: number;
+}
+export interface MerchantInterestAnalysis {
+    fund_flow: string[];
+    responsibility: string[];
+    leverage: string[];
+    stakes: string[];
+    summary: string;
+}
+export declare function analyzeMerchantInterest(input: MerchantInterestInput): MerchantInterestAnalysis;

package/dist/participation/merchant-interest.js

@@ -0,0 +1,100 @@
+export function analyzeMerchantInterest(input) {
+    const fund_flow = [];
+    const responsibility = [];
+    const leverage = [];
+    const stakes = [];
+    const token = input.token_type ? ` (${input.token_type})` : "";
+    if (input.terminal === "completed") {
+        fund_flow.push("Order reached a completion terminal: escrowed funds are released through the Allocation waterfall. " +
+            "Verify your expected share arrived (query the Allocation/Treasury objects).");
+    }
+    else if (input.terminal === "refunded") {
+        fund_flow.push("Order reached a refund terminal: escrowed funds returned to the buyer per the Allocation configuration. " +
+            "No settlement remains for this order.");
+    }
+    else {
+        if (input.order_amount != null) {
+            fund_flow.push(`${input.order_amount} raw units${token} sit escrowed in the Order object — ` +
+                "released ONLY by workflow advancement to a completion path (not by time, not by platform decision).");
+        }
+        if (input.allocation) {
+            const a = input.allocation;
+            const parts = [`settlement splits across ${a.recipient_slots} recipient slot(s)`];
+            if (a.direct_to_me_slots > 0)
+                parts.push(`${a.direct_to_me_slots} pay directly to you`);
+            if (a.guard_gated_slots > 0)
+                parts.push(`${a.guard_gated_slots} are guard-resolved at settlement time (recipient not statically known)`);
+            if (a.to_payer_slots > 0)
+                parts.push(`${a.to_payer_slots} route back to the payer (refund-oriented)`);
+            fund_flow.push(`Allocation waterfall: ${parts.join("; ")}.`);
+        }
+        else {
+            fund_flow.push("Allocation waterfall not configured or unresolved — settlement recipients unknown; " +
+                "funds may sit in the Order until an allocation is set or refund path triggers.");
+        }
+    }
+    if (input.compensation_fund != null && input.compensation_fund !== "0") {
+        fund_flow.push(`Service compensation_fund holds ${input.compensation_fund} raw units${token} — merchant-funded skin-in-the-game: ` +
+            "arbitration indemnity is paid FROM it, but it also converts directly into buyer trust (higher preorder confidence).");
+    }
+    const myGated = input.operable.filter(f => f.guard);
+    if (input.operable.length > 0) {
+        responsibility.push(`${input.operable.length} forward(s) are executable by YOUR role right now ` +
+            `(${input.operable.map(f => `'${f.name}'`).join(", ")}): inaction keeps settlement locked and the stall is publicly visible on-chain.`);
+    }
+    if (myGated.length > 0) {
+        responsibility.push(`Forward(s) ${myGated.map(f => `'${f.name}'`).join(", ")} are guard-gated: YOU must satisfy the guard conditions ` +
+            "(evidence, verification, timing) before execution — prepare submissions (proof/repository data) in advance.");
+    }
+    if (input.terminal == null && input.operable.length === 0 && input.waiting_on.length > 0) {
+        responsibility.push("No forward is yours at this node — you carry no execution responsibility here; " +
+            "avoid interfering outside your permission scope (creates semantic responsibility without authority).");
+    }
+    if (input.operable.length > 0 && input.terminal == null) {
+        leverage.push("Advancing NOW shortens your fund-settlement cycle and improves your publicly-visible flow statistics " +
+            "(future buyers' trust evaluation reads stall/dispute metrics).");
+    }
+    const waitingOnCustomer = input.waiting_on.some(w => w.role.includes("OrderHolder"));
+    if (waitingOnCustomer && input.terminal == null) {
+        leverage.push("The workflow waits on the customer (OrderHolder): a Messenger nudge accelerates fund release " +
+            "without creating semantic responsibility — and the conversation is recorded as WTS evidence protecting YOU in a dispute.");
+    }
+    if (myGated.length > 0) {
+        leverage.push("Uploading delivery evidence (Repository/proof) BEFORE executing guard-gated forwards reduces dispute probability " +
+            "and pre-builds your arbitration defense.");
+    }
+    if ((input.unread_messages ?? 0) > 0) {
+        leverage.push(`${input.unread_messages} unread message(s) from this order's counterparties — timely replies protect your position (WTS record).`);
+    }
+    if (input.rewards_count > 0) {
+        leverage.push(`${input.rewards_count} reward(s) configured on the Service — honoring them (discounts/bonuses) builds repeat-buyer rate and like/dislike reputation.`);
+    }
+    if (input.arbitration_bound && input.terminal == null) {
+        const fundNote = input.compensation_fund != null && input.compensation_fund !== "0"
+            ? `indemnity would be paid from the compensation_fund (${input.compensation_fund} raw units)`
+            : "the compensation_fund is empty (indemnity unenforceable — but the arb-loss record still lands)";
+        stakes.push(`A dispute path exists: if the customer opens arbitration and you lose, ${fundNote}, ` +
+            "and the loss is permanently recorded (arb-loss rate is a public metric in future buyers' trust evaluation).");
+    }
+    if (input.stalled_hours != null && input.stalled_hours > 72 && input.terminal == null) {
+        stakes.push(`Order stalled ${Math.round(input.stalled_hours)}h: prolonged stalls degrade merchant flow statistics ` +
+            "and invite dispute/dislike — the two cheapest reputation losses to avoid.");
+    }
+    if (input.terminal === "refunded") {
+        stakes.push("Refund executed: settlement lost. Remaining stakes are reputational — a dislike vote is the customer's residual leverage; " +
+            "a professional post-refund Messenger close-out is your residual protection.");
+    }
+    const pos = input.terminal === "completed"
+        ? "order completed — settlement released"
+        : input.terminal === "refunded"
+            ? "order refunded — settlement lost"
+            : input.operable.length > 0
+                ? `YOU can advance ${input.operable.length} forward(s) — settlement speed is in your hands`
+                : `waiting on ${input.waiting_on.map(w => w.role).join(", ") || "others"} — monitor and nudge`;
+    const exposure = input.compensation_fund != null && input.compensation_fund !== "0"
+        ? ` Compensation fund at risk: ${input.compensation_fund} raw units.`
+        : "";
+    const summary = `Merchant interest at node '${input.current_node || "(entry)"}': ${pos}.${exposure} ` +
+        "All options above are informational — the decision is yours.";
+    return { fund_flow, responsibility, leverage, stakes, summary };
+}

package/dist/participation/radar-core.d.ts

@@ -0,0 +1,104 @@
+import type { PermissionObjectData } from "../schema/utils/permission-machine-check.js";
+export interface RadarMachineNode {
+    name: string;
+    pairs?: Array<{
+        prev_node: string;
+        forwards?: Array<{
+            name: string;
+            permissionIndex?: number | null;
+            namedOperator?: string | null;
+            guard?: string | null;
+            weight?: number | null;
+        }>;
+    }>;
+}
+export interface NodeAnnotations {
+    completed?: string[];
+    refunded?: string[];
+}
+export interface OrderRadarInput {
+    account: string;
+    progress_address: string;
+    order_address?: string;
+    current_node: string;
+    order_holder?: string;
+    machine_nodes?: RadarMachineNode[];
+    permission?: PermissionObjectData | null;
+    named_accounts?: Record<string, string | string[]>;
+    node_annotations?: NodeAnnotations;
+    claimable_rewards?: Array<{
+        address: string;
+        description?: string;
+        already_claimed?: boolean;
+    }>;
+    pending_compensation?: {
+        arbitration: string;
+        note?: string;
+    };
+    rating_pending?: boolean;
+    discount_available?: string;
+    last_progress_at?: number;
+    now?: number;
+    unread_messages?: number;
+}
+export type ParticipationPerspective = "customer" | "operator" | "observer";
+export type ExecutionPath = "order_holder" | "permission" | "named_operator" | "not_available";
+export interface RadarForward {
+    name: string;
+    to_node: string;
+    execution_path: ExecutionPath;
+    permission_index?: number;
+    named_operator?: string;
+    guard?: string;
+    semantics: string;
+    consequence?: string;
+}
+export interface PendingClaim {
+    kind: "reward" | "discount" | "compensation" | "rating";
+    label: string;
+    how: string;
+}
+export interface RoleSummary {
+    label: string;
+    can_act_now: boolean;
+}
+export interface OrderRadarResult {
+    account: string;
+    progress: string;
+    order?: string;
+    current_node: string;
+    perspective: ParticipationPerspective;
+    roles: RoleSummary[];
+    operable: RadarForward[];
+    branch_choice?: {
+        message: string;
+        options: Array<{
+            forward: string;
+            to_node: string;
+            consequence?: string;
+        }>;
+    };
+    waiting_on: Array<{
+        role: string;
+        forwards: string[];
+    }>;
+    pending_claims: PendingClaim[];
+    interest_hints: string[];
+    workflow_unknown: boolean;
+    interest_analysis?: import("./merchant-interest.js").MerchantInterestAnalysis;
+    summary: string;
+}
+export declare function analyzeOrderParticipation(input: OrderRadarInput): OrderRadarResult;
+export interface AccountRadarDashboard {
+    account: string;
+    orders_analyzed: number;
+    actionable: OrderRadarResult[];
+    waiting: OrderRadarResult[];
+    all_pending_claims: Array<PendingClaim & {
+        progress: string;
+    }>;
+    unread_messages_total: number;
+    summary: string;
+}
+export declare function aggregateRadar(results: OrderRadarResult[], unreadTotal?: number): AccountRadarDashboard;
+export declare function isConsequenceNode(nodeName: string, kind: keyof Required<NodeAnnotations>, annotations?: NodeAnnotations): boolean;