@wowok/agent-mcp 2.6.1 → 2.6.4

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;

package/dist/participation/radar-core.js

@@ -0,0 +1,269 @@
+const DEFAULT_ANNOTATIONS = {
+    completed: ["complete", "completed", "done", "finish", "finished", "delivered", "accepted"],
+    refunded: ["refund", "refunded", "cancelled", "canceled", "lost", "closed"],
+};
+export function analyzeOrderParticipation(input) {
+    const annotations = {
+        completed: input.node_annotations?.completed ?? DEFAULT_ANNOTATIONS.completed,
+        refunded: input.node_annotations?.refunded ?? DEFAULT_ANNOTATIONS.refunded,
+    };
+    const current = input.current_node ?? "";
+    const isOrderHolder = !!input.order_holder && input.order_holder === input.account;
+    const heldIndexes = new Set();
+    if (input.permission?.entityPermissions) {
+        for (const [entity, indexes] of input.permission.entityPermissions) {
+            if (entity === input.account) {
+                for (const idx of indexes)
+                    heldIndexes.add(idx);
+            }
+        }
+    }
+    const perspective = isOrderHolder
+        ? "customer"
+        : heldIndexes.size > 0
+            ? "operator"
+            : "observer";
+    const operable = [];
+    const waiting = [];
+    const workflowUnknown = !input.machine_nodes;
+    if (input.machine_nodes) {
+        for (const node of input.machine_nodes) {
+            for (const pair of node.pairs ?? []) {
+                if (pair.prev_node !== current)
+                    continue;
+                for (const fwd of pair.forwards ?? []) {
+                    const rf = resolveForward(fwd, node.name, input, isOrderHolder, heldIndexes, annotations);
+                    if (rf.execution_path === "not_available") {
+                        const role = fwd.permissionIndex != null
+                            ? `permission index ${fwd.permissionIndex}`
+                            : fwd.namedOperator === ""
+                                ? "OrderHolder (customer)"
+                                : `named operator '${fwd.namedOperator}'`;
+                        const entry = waiting.find(w => w.role === role);
+                        if (entry)
+                            entry.forwards.push(rf.name);
+                        else
+                            waiting.push({ role, forwards: [rf.name] });
+                    }
+                    else {
+                        operable.push(rf);
+                    }
+                }
+            }
+        }
+    }
+    const roles = [];
+    if (isOrderHolder) {
+        roles.push({
+            label: "OrderHolder (customer)",
+            can_act_now: operable.some(f => f.execution_path === "order_holder"),
+        });
+    }
+    for (const idx of [...heldIndexes].sort((a, b) => a - b)) {
+        roles.push({
+            label: `permission index ${idx}`,
+            can_act_now: operable.some(f => f.permission_index === idx),
+        });
+    }
+    if (input.named_accounts) {
+        for (const [name, addr] of Object.entries(input.named_accounts)) {
+            if (nameResolvesTo(addr, input.account)) {
+                roles.push({
+                    label: `named operator '${name}'`,
+                    can_act_now: operable.some(f => f.named_operator === name),
+                });
+            }
+        }
+    }
+    let branchChoice;
+    if (operable.length > 1) {
+        branchChoice = {
+            message: `${operable.length} operations are available to you at node '${current || "(entry)"}'. ` +
+                `Each leads to a different outcome — review the consequences and choose; no one else can make this decision for you.`,
+            options: operable.map(f => ({
+                forward: f.name,
+                to_node: f.to_node,
+                consequence: f.consequence,
+            })),
+        };
+    }
+    const claims = [];
+    for (const r of input.claimable_rewards ?? []) {
+        if (r.already_claimed)
+            continue;
+        claims.push({
+            kind: "reward",
+            label: r.description ?? `Reward ${r.address}`,
+            how: `onchain_operations reward op='claim' (object='${r.address}')`,
+        });
+    }
+    if (input.pending_compensation) {
+        claims.push({
+            kind: "compensation",
+            label: input.pending_compensation.note ?? "Arbitration indemnity awarded to you",
+            how: `onchain_operations service op='compensation_claim' (arbitration='${input.pending_compensation.arbitration}') — paid directly from the Service compensation_fund`,
+        });
+    }
+    if (input.discount_available) {
+        claims.push({
+            kind: "discount",
+            label: input.discount_available,
+            how: "Mention the discount when placing the next order (reward discount config applies at purchase)",
+        });
+    }
+    if (input.rating_pending) {
+        claims.push({
+            kind: "rating",
+            label: "Rate this transaction (like/dislike) — builds on-chain reputation for both sides",
+            how: "onchain_operations operation_type='personal', data.mark={op:'like'|'dislike', address:'<merchant address>'} — votes through registrar::like/dislike into the PUBLIC aggregate count",
+        });
+    }
+    const hints = buildInterestHints(input, perspective, operable, waiting, current);
+    const summary = buildSummary(input, perspective, roles, operable, waiting, claims, workflowUnknown, current);
+    return {
+        account: input.account,
+        progress: input.progress_address,
+        order: input.order_address,
+        current_node: current,
+        perspective,
+        roles,
+        operable,
+        branch_choice: branchChoice,
+        waiting_on: waiting,
+        pending_claims: claims,
+        interest_hints: hints,
+        workflow_unknown: workflowUnknown,
+        summary,
+    };
+}
+export function aggregateRadar(results, unreadTotal) {
+    const actionable = results
+        .filter(r => r.operable.length > 0 || r.pending_claims.length > 0)
+        .sort((a, b) => (a.perspective === "customer" ? 0 : 1) - (b.perspective === "customer" ? 0 : 1));
+    const waiting = results.filter(r => r.operable.length === 0 && r.pending_claims.length === 0);
+    const allClaims = results.flatMap(r => r.pending_claims.map(c => ({ ...c, progress: r.progress })));
+    const summary = results.length === 0
+        ? "No in-flight orders found for this account."
+        : `${results.length} in-flight order(s): ${actionable.length} need your action or have claims, ${waiting.length} are waiting on other roles. ` +
+            (allClaims.length > 0 ? `${allClaims.length} unclaimed benefit(s) detected. ` : "") +
+            (actionable.length > 0 ? `Top priority: ${actionable[0].summary}` : "Nothing requires your action right now.");
+    return {
+        account: results[0]?.account ?? "",
+        orders_analyzed: results.length,
+        actionable,
+        waiting,
+        all_pending_claims: allClaims,
+        unread_messages_total: unreadTotal ?? 0,
+        summary,
+    };
+}
+function nameResolvesTo(value, account) {
+    if (!value)
+        return false;
+    return Array.isArray(value) ? value.includes(account) : value === account;
+}
+export function isConsequenceNode(nodeName, kind, annotations) {
+    const list = annotations?.[kind] ?? DEFAULT_ANNOTATIONS[kind];
+    const lower = (nodeName ?? "").toLowerCase();
+    return list.some(n => lower.includes(n));
+}
+function resolveForward(fwd, nodeName, input, isOrderHolder, heldIndexes, annotations) {
+    let path = "not_available";
+    if (fwd.permissionIndex != null) {
+        if (heldIndexes.has(fwd.permissionIndex))
+            path = "permission";
+    }
+    else if (fwd.namedOperator === "") {
+        if (isOrderHolder)
+            path = "order_holder";
+    }
+    else if (fwd.namedOperator != null) {
+        const resolved = input.named_accounts?.[fwd.namedOperator];
+        if (nameResolvesTo(resolved, input.account))
+            path = "named_operator";
+    }
+    const toNode = nodeName;
+    const semantics = describeForward(fwd.name ?? "", toNode, path, fwd.permissionIndex, fwd.namedOperator);
+    const consequence = consequenceOf(toNode, annotations);
+    return {
+        name: fwd.name ?? "(unnamed)",
+        to_node: toNode,
+        execution_path: path,
+        permission_index: fwd.permissionIndex ?? undefined,
+        named_operator: fwd.namedOperator ?? undefined,
+        guard: fwd.guard ?? undefined,
+        semantics,
+        consequence,
+    };
+}
+function describeForward(name, toNode, path, permissionIndex, namedOperator) {
+    const gate = permissionIndex != null
+        ? `requires permission index ${permissionIndex}`
+        : namedOperator === ""
+            ? "executable by the order holder (customer)"
+            : `executable by named operator '${namedOperator}'`;
+    const access = path === "not_available" ? "You CANNOT execute this" : "You CAN execute this";
+    return `'${name}' advances the order to node '${toNode}' (${gate}). ${access}.`;
+}
+function consequenceOf(toNode, annotations) {
+    if (isConsequenceNode(toNode, "completed", annotations)) {
+        return "Completion path — funds are released to the merchant per the Allocation waterfall; refunds become harder after this point.";
+    }
+    if (isConsequenceNode(toNode, "refunded", annotations)) {
+        return "Refund/cancellation path — escrowed funds return to the buyer per the Allocation configuration.";
+    }
+    return undefined;
+}
+function buildInterestHints(input, perspective, operable, waiting, current) {
+    const hints = [];
+    const now = input.now ?? Date.now();
+    const stalledHours = input.last_progress_at != null
+        ? (now - input.last_progress_at) / 3_600_000
+        : undefined;
+    if (perspective === "customer") {
+        if (operable.length > 0) {
+            hints.push("Your confirmation is the fund-release trigger: escrowed money stays locked until YOU act — only confirm when the deliverable matches the agreement.");
+        }
+        if (waiting.some(w => w.role !== "OrderHolder (customer)")) {
+            hints.push("Delivery depends on the merchant-side roles listed in waiting_on; if they stall, Messenger first, then consider dispute via the bound Arbitration.");
+        }
+        if (stalledHours != null && stalledHours > 24) {
+            hints.push(`Order has not advanced for ${Math.round(stalledHours)}h. Your leverage: compensation_fund (if any) + arbitration + on-chain reputation (dislike) — in that order.`);
+        }
+    }
+    else if (perspective === "operator") {
+        const myBlocking = waiting.filter(w => w.role.startsWith("permission index"));
+        if (operable.length > 0) {
+            hints.push("Advancing the workflow NOW improves flow efficiency and shortens your fund-settlement cycle; stalled orders degrade your on-chain reputation metrics (dispute rate, stall statistics).");
+        }
+        if (myBlocking.length > 0) {
+            hints.push("Nodes waiting on YOUR permission indexes are your responsibility surface: prolonged inaction may trigger timeout penalties or disputes recorded permanently on-chain.");
+        }
+        if (current && operable.length === 0) {
+            hints.push("Nothing for you to execute at this node — monitor only; avoid unnecessary interference that creates semantic responsibility.");
+        }
+    }
+    else {
+        hints.push("You hold no operative role on this order (observer). On-chain data remains transparent to you for auditing.");
+    }
+    if ((input.unread_messages ?? 0) > 0) {
+        hints.push(`${input.unread_messages} unread Messenger message(s) — negotiation evidence (WTS) forms the arbitration record; timely replies protect your position.`);
+    }
+    return hints;
+}
+function buildSummary(input, perspective, roles, operable, waiting, claims, workflowUnknown, current) {
+    const roleText = roles.length > 0
+        ? roles.map(r => r.label).join(", ")
+        : "no operative role";
+    const nodeText = current === "" ? "(entry, not started)" : `'${current}'`;
+    if (workflowUnknown) {
+        return `Order ${input.progress_address} is at ${nodeText}; you are ${perspective} (${roleText}). Machine workflow data unavailable — fetch the bound Machine to see executable operations.`;
+    }
+    const actionText = operable.length > 0
+        ? `you can execute: ${operable.map(f => `'${f.name}'→'${f.to_node}'`).join(", ")}`
+        : waiting.length > 0
+            ? `waiting on ${waiting.map(w => w.role).join(", ")}`
+            : "no pending operations at this node";
+    const claimText = claims.length > 0 ? ` ${claims.length} unclaimed benefit(s).` : "";
+    return `Order at ${nodeText}; you are ${perspective} (${roleText}) — ${actionText}.${claimText}`;
+}

package/dist/project/context-assembly.js

@@ -1,5 +1,6 @@
 import { createHash } from "crypto";
 import { query_objects, query_events } from "@wowok/wowok";
+import { annotateEventsMonetaryFields } from "../knowledge/fund-layer.js";
 import { buildDataSemantic } from "../schema/call/semantic.js";
 import { collectContextExperience } from "../loop-engineering/context-collect.js";
 const STATE_TRANSITION_EVENTS = [
@@ -46,6 +47,13 @@ export async function assembleContext(validated) {
         if (events.length === 0) {
             events = undefined;
         }
+        else {
+            try {
+                await annotateEventsMonetaryFields(events, network);
+            }
+            catch {
+            }
+        }
     }
     const semanticCtx = {
         operation_type: "assemble_context",

package/dist/project/deployment-bridge.js

@@ -1,5 +1,6 @@
 import { LocalProject } from "@wowok/wowok";
 import { generateDeploymentDoc, validateDeploymentDoc } from "./deployment-doc.js";
+import { isObjectOfType, shortTypeName } from "../schema/utils/object-type-utils.js";
 export async function generateDeploymentDocFromProject(projectId, network, detailLevel) {
     const project = await LocalProject.Instance().getProject(projectId);
     if (!project) {
@@ -26,7 +27,7 @@ export async function generateDeploymentDocFromProject(projectId, network, detai
             (o.objectAddress.startsWith("draft:") ? "draft" : "deployed");
         const config = meta.config ?? undefined;
         const publishRequired = meta.publish_required ??
-            (objectType === "service" || objectType === "machine");
+            (isObjectOfType(objectType, "service") || isObjectOfType(objectType, "machine"));
         return {
             entry_id: `${objectType}:${o.objectName || o.objectAddress || o.id}`,
             object_type: normalizeObjectType(objectType),
@@ -35,7 +36,7 @@ export async function generateDeploymentDocFromProject(projectId, network, detai
                 ? o.objectAddress : undefined,
             publish_required: publishRequired,
             description: meta.description ??
-                (status === "draft" ? "[蓝图] 待上链" : "[已上链]"),
+                (status === "draft" ? "[blueprint] pending on-chain" : "[on-chain]"),
             config,
             status,
         };
@@ -85,10 +86,10 @@ export async function generateDeploymentDocFromProject(projectId, network, detai
     return { markdown, validation };
 }
 function normalizeObjectType(raw) {
-    const lower = raw.toLowerCase();
-    if (lower === "arbitration")
+    const short = shortTypeName(raw).toLowerCase();
+    if (short === "arbitration")
         return "arb";
-    return lower;
+    return short;
 }
 function buildTopoSteps(objects, edges, network) {
     const typeOrder = {

package/dist/project/deployment-doc.js

@@ -1,7 +1,7 @@
 import { join } from "path";
 const STANDARD_TOPO_ORDER = [
-    "permission", "treasury", "allocation", "guard", "machine",
-    "service", "order", "progress", "arb", "reward",
+    "permission", "treasury", "allocation", "service", "guard", "machine",
+    "order", "progress", "arb", "reward",
     "proof", "repository", "demand", "contact",
     "personal", "payment",
 ];
@@ -230,7 +230,7 @@ function renderNetworkSection(sectionNum, network, input) {
             data: {
                 object: objectData,
                 description: isDraft
-                    ? `${stepDescription(step)} [蓝图：基于 ${input.industry} 行业模板生成]`
+                    ? `${stepDescription(step)} [blueprint: generated from ${input.industry} industry template]`
                     : stepDescription(step),
                 status: isDraft ? "draft" : "deployed",
             },
@@ -1028,8 +1028,8 @@ function renderProjectReadme(input, relations) {
     lines.push("| stage 4 (steps) | stage 5 (substeps) | Steps must be defined before substep tracing |");
     lines.push("");
     lines.push("## §8 Gas / Faucet Rules", "");
-    lines.push("- testnet: gas is free (faucet) — encourage experimentation,回退无成本");
-    lines.push("- mainnet: gas is real — 回退后重跑有真实成本, WARN before rollback");
+    lines.push("- testnet: gas is free (faucet) — encourage experimentation, rollback is costless");
+    lines.push("- mainnet: gas is real — re-running after rollback incurs real cost, WARN before rollback");
     lines.push("- Reversibility is determined by object lifecycle (§3.2), NOT by network");
     lines.push("");
     lines.push("## §9 Stage Subdirectory Index", "");

package/dist/project/edit-planner.d.ts

@@ -0,0 +1,123 @@
+import type { z } from "zod";
+import { type MachineNodeForRender, type MachineEdgeForRender } from "../knowledge/machine-render.js";
+import { type GuardNodeForRender } from "../knowledge/guard-render.js";
+import type { ProjectOperationInputSchema } from "../schema/project/index.js";
+type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
+export declare function handlePlanObjectEdit(v: ProjectInput): Promise<{
+    action: "plan_object_edit";
+    plan_id: string;
+    object_kind: "guard" | "machine";
+    object_address: string;
+    object_name: string | null;
+    expected_hash: string;
+    diff: {
+        added: string[];
+        removed: string[];
+        modified: string[];
+        summary: string;
+    };
+    warnings: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    blocking_errors: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    can_apply: boolean;
+    prepared_call: unknown;
+    expires_at: string;
+    summary: string;
+}>;
+export declare function handleApplyObjectEdit(v: ProjectInput): Promise<{
+    action: "apply_object_edit";
+    plan_id: string;
+    applied: boolean;
+    hash_match: boolean;
+    prepared_call: null;
+    error: string;
+    next_step: string;
+} | {
+    action: "apply_object_edit";
+    plan_id: string;
+    applied: boolean;
+    hash_match: boolean;
+    prepared_call: unknown;
+    error: null;
+    next_step: string;
+}>;
+export declare function handlePatchMachineNodes(v: ProjectInput): Promise<{
+    action: "patch_machine_nodes";
+    machine_address: string;
+    machine_name: string | null;
+    operations_applied: number;
+    operations_failed: {
+        operation: string;
+        error: string;
+    }[];
+    patched_nodes: MachineNodeForRender[];
+    patched_edges: MachineEdgeForRender[];
+    diff: {
+        added: string[];
+        removed: string[];
+        modified: string[];
+        summary: string;
+    };
+    warnings: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    blocking_errors: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    can_apply: boolean;
+    prepared_call: unknown;
+    summary: string;
+}>;
+export declare function handlePatchGuardTree(v: ProjectInput): Promise<{
+    action: "patch_guard_tree";
+    guard_address: string;
+    guard_name: string | null;
+    operations_applied: number;
+    operations_failed: {
+        operation: string;
+        error: string;
+    }[];
+    patched_root: GuardNodeForRender;
+    patched_table: {
+        identifier: number;
+        name?: string;
+        value_type: string | number;
+        b_submission: boolean;
+        value?: unknown;
+    }[];
+    patched_rely: {
+        guards: string[];
+        logic_or?: boolean;
+    } | null;
+    diff: {
+        added: string[];
+        removed: string[];
+        modified: string[];
+        summary: string;
+    };
+    warnings: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    blocking_errors: {
+        id: string;
+        description: string;
+        impact: string;
+    }[];
+    can_apply: boolean;
+    prepared_call: unknown;
+    summary: string;
+}>;
+export {};