@wowok/agent-mcp 2.6.3 → 2.6.4

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/edit-planner.js

@@ -1,5 +1,6 @@
 import { randomUUID, createHash } from "node:crypto";
-import { LocalProject, LocalMark, query_objects, query_table } from "@wowok/wowok";
+import { LocalProject, LocalMark, query_objects } from "@wowok/wowok";
+import { fetchMachineNodes } from "./machine-nodes.js";
 import { parseMachineTreeIndented, } from "../knowledge/machine-render.js";
 import { parseGuardTreeIndented, parseGuardTableJSON, } from "../knowledge/guard-render.js";
 const PLAN_TTL_MS = 10 * 60 * 1000;
@@ -673,63 +674,33 @@ export async function handleApplyObjectEdit(v) {
     };
 }
 async function fetchCurrentMachine(machineAddress, network) {
-    const allFieldObjectIds = [];
-    let cursor = undefined;
-    for (;;) {
-        const tableResult = await query_table({
-            parent: machineAddress,
-            cursor: cursor ?? undefined,
-            network,
-        });
-        if (!tableResult?.items || tableResult.items.length === 0)
-            break;
-        for (const item of tableResult.items) {
-            if (item.object)
-                allFieldObjectIds.push(item.object);
-        }
-        if (!tableResult.hasNextPage || !tableResult.nextCursor)
-            break;
-        cursor = tableResult.nextCursor;
-    }
+    const rawNodes = await fetchMachineNodes(machineAddress, network);
     const nodeMap = new Map();
     const edges = [];
-    if (allFieldObjectIds.length > 0) {
-        const BATCH = 50;
-        for (let i = 0; i < allFieldObjectIds.length; i += BATCH) {
-            const batch = allFieldObjectIds.slice(i, i + BATCH);
-            const nodeQueryResult = await query_objects({
-                objects: batch,
-                network,
-            });
-            for (const obj of nodeQueryResult?.objects ?? []) {
-                if (obj.type === "TableItem_MachineNode") {
-                    const nodeObj = obj;
-                    const nodeName = nodeObj.name;
-                    if (!nodeName)
-                        continue;
-                    if (!nodeMap.has(nodeName)) {
-                        nodeMap.set(nodeName, { name: nodeName, description: null });
-                    }
-                    const pairs = Array.isArray(nodeObj.value) ? nodeObj.value : [];
-                    for (const pair of pairs) {
-                        if (!pair || typeof pair !== "object")
-                            continue;
-                        const from = typeof pair.prev_node === "string" ? pair.prev_node : "";
-                        const to = nodeName;
-                        const threshold = typeof pair.threshold === "number" ? pair.threshold : 1;
-                        const forwardsRaw = Array.isArray(pair.forwards) ? pair.forwards : [];
-                        const forwards = forwardsRaw.map((f) => ({
-                            name: f.name ?? "",
-                            weight: f.weight ?? 1,
-                            named_operator: f.namedOperator ?? null,
-                            permission_index: f.permissionIndex ?? null,
-                            guard: f.guard?.guard ?? f.guard ?? null,
-                            retained_submission: f.retained_submission ?? null,
-                        }));
-                        edges.push({ from, to, threshold, forwards });
-                    }
-                }
-            }
+    for (const nodeObj of rawNodes) {
+        const nodeName = nodeObj.name;
+        if (!nodeName)
+            continue;
+        if (!nodeMap.has(nodeName)) {
+            nodeMap.set(nodeName, { name: nodeName, description: null });
+        }
+        const pairs = Array.isArray(nodeObj.value) ? nodeObj.value : [];
+        for (const pair of pairs) {
+            if (!pair || typeof pair !== "object")
+                continue;
+            const from = typeof pair.prev_node === "string" ? pair.prev_node : "";
+            const to = nodeName;
+            const threshold = typeof pair.threshold === "number" ? pair.threshold : 1;
+            const forwardsRaw = Array.isArray(pair.forwards) ? pair.forwards : [];
+            const forwards = forwardsRaw.map((f) => ({
+                name: f.name ?? "",
+                weight: f.weight ?? 1,
+                named_operator: f.namedOperator ?? null,
+                permission_index: f.permissionIndex ?? null,
+                guard: f.guard?.guard ?? f.guard ?? null,
+                retained_submission: f.retained_submission ?? null,
+            }));
+            edges.push({ from, to, threshold, forwards });
         }
     }
     for (const edge of edges) {

package/dist/project/evaluation.d.ts

@@ -32,6 +32,42 @@ export interface EvaluationInput {
 }
 export declare function getNumberField(data: Record<string, unknown> | null, field: string): number;
 export declare function getMachineNodeCount(data: Record<string, unknown> | null): number;
+export declare const RISK_WEIGHTS: {
+    readonly structural_risk: 0.25;
+    readonly fund_safety: 0.2;
+    readonly operational_risk: 0.15;
+    readonly governance_risk: 0.1;
+    readonly graph_coherence: 0.2;
+    readonly mode_registry: 0.1;
+};
+export declare const TRUST_WEIGHTS: {
+    readonly reputation: 0.25;
+    readonly arbitration_coverage: 0.2;
+    readonly guard_quality: 0.2;
+    readonly transparency: 0.15;
+    readonly consumer_diligence: 0.2;
+};
+export declare const COMPLETENESS_WEIGHTS: {
+    readonly object_coverage: 0.3;
+    readonly binding_completeness: 0.25;
+    readonly workflow_rationality: 0.2;
+    readonly deployment_readiness: 0.25;
+};
+export declare const EXTENDED_DIMENSION_WEIGHTS: {
+    readonly escrow_quality: 0.15;
+    readonly proof_integrity: 0.1;
+    readonly arbitration_fairness: 0.15;
+    readonly fee_transparency: 0.1;
+    readonly timeout_protection: 0.1;
+    readonly supplier_visibility: 0.1;
+    readonly content_commitment: 0.1;
+    readonly reputation_verifiability: 0.1;
+    readonly permission_safety: 0.1;
+};
+export declare function finalizeCriterionScores(baseScores: CriterionScore[], perspective: Project["perspective"]): {
+    criterionScores: CriterionScore[];
+    overall: number;
+};
 export declare function runEvaluation(input: EvaluationInput, evaluationType: EvaluationType, llmPrompt?: string): EvaluationResult;
 export interface ProjectComparisonEntry {
     projectId: string;