@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/knowledge/machine-render.js

@@ -0,0 +1,565 @@
+function sanitizeMermaidLabel(text) {
+    if (/[<>"\[\]{}()|&]/.test(text)) {
+        return `"${text.replace(/"/g, "'")}"`;
+    }
+    return text;
+}
+const MACHINE_NODE_COLORS = {
+    entry: { fill: "#10b981", stroke: "#065f46" },
+    terminal: { fill: "#ef4444", stroke: "#991b1b" },
+    revision: { fill: "#f59e0b", stroke: "#92400e" },
+    normal: { fill: "#3b82f6", stroke: "#1e40af" },
+};
+function classifyMachineNode(nodeName, edges, entryNodes) {
+    const outEdges = edges.filter(e => e.from === nodeName);
+    if (outEdges.length === 0)
+        return "terminal";
+    const hasOutgoingToNode = outEdges.some(e => e.to !== "");
+    if (!hasOutgoingToNode)
+        return "terminal";
+    const isRevisionTarget = edges.some(e => e.to === nodeName && e.from === nodeName);
+    if (isRevisionTarget)
+        return "revision";
+    if (entryNodes.has(nodeName))
+        return "entry";
+    return "normal";
+}
+export function sanitizeMermaidNodeId(name) {
+    if (/[^a-zA-Z0-9_]/.test(name)) {
+        return `"${name}"`;
+    }
+    return name;
+}
+export function renderMachineMermaid(nodes, edges, options) {
+    const colored = options?.colored !== false;
+    const lines = ["stateDiagram-v2"];
+    if (colored) {
+        lines.push("  %% Color Legend (BehaviorTree.CPP-inspired workflow roles):");
+        lines.push("  %%   green  #10b981 - entry    (start state, targeted by [*])");
+        lines.push("  %%   red    #ef4444 - terminal (end state, no outgoing edges)");
+        lines.push("  %%   amber  #f59e0b - revision (self-loop / revision cycle)");
+        lines.push("  %%   blue   #3b82f6 - normal   (regular intermediate state)");
+        lines.push("  %% Priority: terminal > revision > entry > normal");
+    }
+    const nodesWithIncoming = new Set(edges.filter(e => e.from !== "").map(e => e.to));
+    const entryNodes = new Set();
+    for (const node of nodes) {
+        if (!nodesWithIncoming.has(node.name)) {
+            entryNodes.add(node.name);
+        }
+    }
+    const entryNodesList = nodes.filter(n => entryNodes.has(n.name));
+    for (const entry of entryNodesList) {
+        const entryEdges = edges.filter(e => e.from === "" && e.to === entry.name);
+        if (entryEdges.length > 0) {
+            for (const edge of entryEdges) {
+                for (const fwd of edge.forwards) {
+                    const label = buildForwardLabel(fwd, edge.threshold);
+                    lines.push(`  [*] --> ${sanitizeMermaidNodeId(entry.name)}: ${sanitizeMermaidLabel(label)}`);
+                }
+            }
+        }
+        else {
+            lines.push(`  [*] --> ${sanitizeMermaidNodeId(entry.name)}`);
+        }
+    }
+    for (const edge of edges) {
+        if (edge.from === "")
+            continue;
+        const fromId = sanitizeMermaidNodeId(edge.from);
+        const toId = edge.to === "" ? "[*]" : sanitizeMermaidNodeId(edge.to);
+        for (const fwd of edge.forwards) {
+            const label = buildForwardLabel(fwd, edge.threshold);
+            lines.push(`  ${fromId} --> ${toId}: ${sanitizeMermaidLabel(label)}`);
+        }
+    }
+    for (const node of nodes) {
+        if (node.description) {
+            lines.push(`  ${sanitizeMermaidNodeId(node.name)}: ${sanitizeMermaidLabel(node.description)}`);
+        }
+    }
+    if (colored) {
+        lines.push("");
+        lines.push("  %% Node colors (BehaviorTree.CPP-inspired workflow roles)");
+        for (const node of nodes) {
+            const category = classifyMachineNode(node.name, edges, entryNodes);
+            const color = MACHINE_NODE_COLORS[category];
+            lines.push(`  style ${sanitizeMermaidNodeId(node.name)} fill:${color.fill},stroke:${color.stroke},color:#fff`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildForwardLabel(fwd, threshold) {
+    let label = fwd.name;
+    const annotations = [];
+    if (threshold > 1) {
+        annotations.push(`threshold=${threshold}`);
+    }
+    if (fwd.guard) {
+        const shortGuard = fwd.guard.length > 10
+            ? `${fwd.guard.slice(0, 6)}…${fwd.guard.slice(-4)}`
+            : fwd.guard;
+        annotations.push(`guard=${shortGuard}`);
+    }
+    if (annotations.length > 0) {
+        label += ` (${annotations.join(", ")})`;
+    }
+    return label;
+}
+export function renderMachineTreeIndented(input) {
+    const { nodes, edges, machineName, machineAddress, published, paused } = input;
+    const lines = [];
+    lines.push("# Machine Workflow Definition");
+    lines.push("");
+    if (machineName) {
+        lines.push(`**Machine:** ${machineName}`);
+    }
+    if (machineAddress) {
+        lines.push(`**Address:** ${machineAddress}`);
+    }
+    lines.push(`**Total Nodes:** ${nodes.length}`);
+    lines.push(`**Total Edges:** ${edges.length}`);
+    if (published !== null && published !== undefined) {
+        lines.push(`**Published:** ${published}`);
+    }
+    if (paused !== null && paused !== undefined) {
+        lines.push(`**Paused:** ${paused}`);
+    }
+    lines.push("");
+    lines.push("## Topology (directed graph outline)");
+    lines.push("");
+    const entryEdges = edges.filter(e => e.from === "");
+    const regularEdges = edges.filter(e => e.from !== "");
+    for (const edge of entryEdges) {
+        const header = `- [*] --> ${edge.to} (threshold=${edge.threshold})`;
+        lines.push(header);
+        for (const fwd of edge.forwards) {
+            lines.push(`  - forward: ${formatForwardInline(fwd)}`);
+        }
+    }
+    for (const edge of regularEdges) {
+        const isSelfLoop = edge.from === edge.to;
+        const annotation = isSelfLoop ? "  # self-loop (revision cycle)" : "";
+        const toLabel = edge.to === "" ? "[*]" : edge.to;
+        const header = `- ${edge.from} --> ${toLabel} (threshold=${edge.threshold})${annotation}`;
+        lines.push(header);
+        for (const fwd of edge.forwards) {
+            lines.push(`  - forward: ${formatForwardInline(fwd)}`);
+        }
+    }
+    const nodesWithDesc = nodes.filter(n => n.description);
+    if (nodesWithDesc.length > 0) {
+        lines.push("");
+        lines.push("## Node Descriptions");
+        lines.push("");
+        for (const node of nodes) {
+            if (node.description) {
+                lines.push(`- ${node.name}: ${node.description}`);
+            }
+        }
+    }
+    const incomingMap = new Map();
+    for (const edge of edges) {
+        if (!incomingMap.has(edge.to))
+            incomingMap.set(edge.to, []);
+        incomingMap.get(edge.to).push({
+            from: edge.from === "" ? "[*]" : edge.from,
+            forwards: edge.forwards.map(f => f.name),
+        });
+    }
+    if (incomingMap.size > 0) {
+        lines.push("");
+        lines.push("## Backrefs (incoming edges per node)");
+        lines.push("");
+        for (const node of nodes) {
+            const incoming = incomingMap.get(node.name);
+            if (!incoming || incoming.length === 0)
+                continue;
+            const parts = incoming.map(inc => {
+                const fwdStr = inc.forwards.length > 0 ? ` (${inc.forwards.join(", ")})` : "";
+                const selfLoop = inc.from === node.name ? " # self-loop" : "";
+                return `<- ${inc.from}${fwdStr}${selfLoop}`;
+            });
+            lines.push(`- ${node.name}: ${parts.join(", ")}`);
+        }
+    }
+    lines.push("");
+    lines.push("## JSON Definition");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify({ nodes, edges }, null, 2));
+    lines.push("```");
+    return lines.join("\n");
+}
+function formatForwardInline(fwd) {
+    const parts = [`weight=${fwd.weight}`];
+    if (fwd.named_operator !== null && fwd.named_operator !== undefined) {
+        parts.push(`namedOperator='${fwd.named_operator}'`);
+    }
+    if (fwd.permission_index !== null && fwd.permission_index !== undefined) {
+        parts.push(`permissionIndex=${fwd.permission_index}`);
+    }
+    if (fwd.guard) {
+        parts.push(`guard=${fwd.guard}`);
+    }
+    if (fwd.retained_submission) {
+        const rsStr = Array.isArray(fwd.retained_submission)
+            ? `[${fwd.retained_submission.join(",")}]`
+            : String(fwd.retained_submission);
+        parts.push(`retained_submission=${rsStr}`);
+    }
+    return `${fwd.name} (${parts.join(", ")})`;
+}
+export function parseMachineTreeIndented(text) {
+    const errors = [];
+    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)```/);
+    if (jsonMatch) {
+        try {
+            const data = JSON.parse(jsonMatch[1].trim());
+            if (data && typeof data === "object" && Array.isArray(data.nodes) && Array.isArray(data.edges)) {
+                return { success: true, data, errors: [] };
+            }
+            if (Array.isArray(data)) {
+                const { nodes, edges } = convertNodeArrayToGraph(data);
+                return { success: true, data: { nodes, edges }, errors: [] };
+            }
+        }
+        catch (e) {
+            errors.push(`JSON code block parse error: ${e.message}`);
+        }
+    }
+    const topologyMatch = text.match(/##\s*Topology[^\n]*\n([\s\S]*?)(?=\n##\s|$)/i);
+    if (!topologyMatch) {
+        return {
+            success: false,
+            errors: [
+                "No '## Topology' section found. " +
+                    "Use the format produced by renderMachineTreeIndented() or a JSON code block.",
+            ],
+        };
+    }
+    const topologySection = topologyMatch[1];
+    const nodeNames = new Set();
+    const edges = [];
+    const edgeLines = topologySection.split("\n").filter(l => l.trim().startsWith("- "));
+    const pendingForwards = [];
+    let currentEdge = null;
+    for (const line of edgeLines) {
+        const trimmed = line.trim();
+        const isIndented = line.startsWith("  -");
+        if (isIndented) {
+            const fwdMatch = trimmed.match(/^-\s*forward:\s*(.+)$/);
+            if (fwdMatch && currentEdge) {
+                const fwd = parseForwardInline(fwdMatch[1]);
+                if (fwd) {
+                    currentEdge.forwards.push(fwd);
+                }
+            }
+            continue;
+        }
+        const edgeMatch = trimmed.match(/^-\s+(.+?)\s+-->\s+(\S+)(?:\s+\(threshold=(\d+)\))?(.*)$/);
+        if (edgeMatch) {
+            if (currentEdge) {
+                edges.push(currentEdge);
+            }
+            const fromRaw = edgeMatch[1].trim();
+            const to = edgeMatch[2].trim();
+            const threshold = edgeMatch[3] ? parseInt(edgeMatch[3], 10) : 1;
+            const from = fromRaw === "[*]" ? "" : fromRaw;
+            currentEdge = {
+                from,
+                to,
+                threshold,
+                forwards: [],
+            };
+            nodeNames.add(to);
+            if (from)
+                nodeNames.add(from);
+        }
+    }
+    if (currentEdge) {
+        edges.push(currentEdge);
+    }
+    if (edges.length === 0) {
+        return {
+            success: false,
+            errors: ["No edges found in '## Topology' section. Expected lines like '- A --> B (threshold=1)'."],
+        };
+    }
+    const descMatch = text.match(/##\s*Node Descriptions[^\n]*\n([\s\S]*?)(?=\n##\s|$)/i);
+    const nodeDescMap = new Map();
+    if (descMatch) {
+        const descLines = descMatch[1].split("\n");
+        for (const line of descLines) {
+            const m = line.match(/^-\s+(\S+):\s*(.+)$/);
+            if (m) {
+                nodeDescMap.set(m[1], m[2]);
+            }
+        }
+    }
+    const nodes = [];
+    for (const name of nodeNames) {
+        nodes.push({
+            name,
+            description: nodeDescMap.get(name) ?? null,
+        });
+    }
+    return { success: true, data: { nodes, edges }, errors };
+}
+function parseForwardInline(text) {
+    const match = text.match(/^(\S+)\s*\(([^)]*)\)$/);
+    if (!match) {
+        return {
+            name: text.trim(),
+            weight: 1,
+            named_operator: null,
+            permission_index: null,
+            guard: null,
+            retained_submission: null,
+        };
+    }
+    const name = match[1];
+    const annotationStr = match[2];
+    const fwd = {
+        name,
+        weight: 1,
+        named_operator: null,
+        permission_index: null,
+        guard: null,
+        retained_submission: null,
+    };
+    for (const part of annotationStr.split(",").map(s => s.trim())) {
+        if (!part)
+            continue;
+        const [key, ...valParts] = part.split("=");
+        const val = valParts.join("=").trim();
+        switch (key.trim()) {
+            case "weight":
+                fwd.weight = parseInt(val, 10) || 1;
+                break;
+            case "namedOperator":
+                fwd.named_operator = val.replace(/^'|'$/g, "");
+                break;
+            case "permissionIndex":
+                fwd.permission_index = parseInt(val, 10) || null;
+                break;
+            case "guard":
+                fwd.guard = val || null;
+                break;
+            case "retained_submission":
+                if (val.startsWith("[") && val.endsWith("]")) {
+                    fwd.retained_submission = val
+                        .slice(1, -1)
+                        .split(",")
+                        .map(s => parseInt(s.trim(), 10))
+                        .filter(n => !isNaN(n));
+                }
+                else {
+                    fwd.retained_submission = val;
+                }
+                break;
+        }
+    }
+    return fwd;
+}
+function convertNodeArrayToGraph(data) {
+    const nodes = [];
+    const edges = [];
+    for (const item of data) {
+        if (!item || typeof item !== "object")
+            continue;
+        const node = item;
+        const name = typeof node.name === "string" ? node.name : "";
+        if (!name)
+            continue;
+        nodes.push({
+            name,
+            description: typeof node.description === "string" ? node.description : null,
+        });
+        const pairs = Array.isArray(node.pairs) ? node.pairs : [];
+        for (const pairRaw of pairs) {
+            if (!pairRaw || typeof pairRaw !== "object")
+                continue;
+            const pair = pairRaw;
+            const prevNode = typeof pair.prev_node === "string" ? pair.prev_node : "";
+            const threshold = typeof pair.threshold === "number" ? pair.threshold : 1;
+            const forwardsRaw = Array.isArray(pair.forwards) ? pair.forwards : [];
+            const forwards = forwardsRaw.map((f) => {
+                const fwd = f;
+                return {
+                    name: typeof fwd.name === "string" ? fwd.name : "",
+                    weight: typeof fwd.weight === "number" ? fwd.weight : 1,
+                    named_operator: typeof fwd.namedOperator === "string" ? fwd.namedOperator : null,
+                    permission_index: typeof fwd.permissionIndex === "number" ? fwd.permissionIndex : null,
+                    guard: typeof fwd.guard === "string"
+                        ? fwd.guard
+                        : (fwd.guard && typeof fwd.guard.guard === "string")
+                            ? fwd.guard.guard
+                            : null,
+                    retained_submission: null,
+                };
+            });
+            edges.push({
+                from: prevNode,
+                to: name,
+                threshold,
+                forwards,
+            });
+        }
+    }
+    return { nodes, edges };
+}
+export function renderMachineAscii(input) {
+    const { nodes, edges, machineName, machineAddress, published, paused } = input;
+    const lines = [];
+    if (machineName) {
+        lines.push(`Machine: ${machineName}`);
+    }
+    if (machineAddress) {
+        lines.push(`Address: ${machineAddress}`);
+    }
+    if (published !== null && published !== undefined) {
+        lines.push(`Published: ${published}`);
+    }
+    if (paused !== null && paused !== undefined) {
+        lines.push(`Paused: ${paused}`);
+    }
+    if (machineName || machineAddress) {
+        lines.push("");
+    }
+    const outgoingMap = new Map();
+    for (const edge of edges) {
+        if (edge.from === "")
+            continue;
+        if (!outgoingMap.has(edge.from))
+            outgoingMap.set(edge.from, []);
+        outgoingMap.get(edge.from).push(edge);
+    }
+    const terminalNodes = new Set();
+    for (const node of nodes) {
+        const outEdges = outgoingMap.get(node.name) ?? [];
+        const hasOutgoingToNode = outEdges.some(e => e.to !== "");
+        if (!hasOutgoingToNode) {
+            const isTargeted = edges.some(e => e.to === node.name);
+            if (isTargeted) {
+                terminalNodes.add(node.name);
+            }
+        }
+    }
+    const entryNodes = new Set();
+    for (const edge of edges) {
+        if (edge.from === "") {
+            entryNodes.add(edge.to);
+        }
+    }
+    const revisionNodes = new Set();
+    for (const edge of edges) {
+        if (edge.from === edge.to && edge.from !== "") {
+            revisionNodes.add(edge.from);
+        }
+    }
+    for (const edge of edges) {
+        const fromLabel = edge.from === "" ? "[*]" : edge.from;
+        const toLabel = edge.to === "" ? "[*]" : edge.to;
+        const isCycle = edge.from === edge.to && edge.from !== "";
+        for (const fwd of edge.forwards) {
+            const annotations = [];
+            if (isCycle)
+                annotations.push("cycle");
+            if (fwd.guard)
+                annotations.push(`guard=${fwd.guard}`);
+            if (fwd.named_operator !== null && fwd.named_operator !== undefined && fwd.named_operator !== "") {
+                annotations.push(`op=${fwd.named_operator}`);
+            }
+            if (fwd.permission_index !== null && fwd.permission_index !== undefined) {
+                annotations.push(`perm=${fwd.permission_index}`);
+            }
+            if (edge.threshold > 1)
+                annotations.push(`threshold=${edge.threshold}`);
+            const annotationStr = annotations.length > 0 ? ` [${annotations.join(", ")}]` : "";
+            const cycleStr = isCycle ? " ⟲" : "";
+            lines.push(`${fromLabel} ─${fwd.name}→ ${toLabel}${cycleStr}${annotationStr}`);
+        }
+    }
+    const annotatedNodes = [];
+    for (const node of nodes) {
+        const annotations = [];
+        if (entryNodes.has(node.name))
+            annotations.push("entry");
+        if (terminalNodes.has(node.name))
+            annotations.push("terminal");
+        if (revisionNodes.has(node.name))
+            annotations.push("revision");
+        if (annotations.length > 0) {
+            annotatedNodes.push(`  ${node.name}: ${annotations.join(", ")}`);
+        }
+    }
+    if (annotatedNodes.length > 0) {
+        lines.push("");
+        lines.push("Node roles:");
+        lines.push(...annotatedNodes);
+    }
+    return lines.join("\n");
+}
+export function renderMachineMarkmap(input) {
+    const { nodes, edges, machineName, machineAddress, published, paused } = input;
+    const lines = [];
+    const titleParts = ["Machine"];
+    if (machineName)
+        titleParts.push(machineName);
+    lines.push(`# ${titleParts.join(": ")}`);
+    if (machineAddress || published !== null || paused !== null) {
+        lines.push("");
+        if (machineAddress)
+            lines.push(`**Address:** ${machineAddress}`);
+        if (published !== null && published !== undefined)
+            lines.push(`**Published:** ${published}`);
+        if (paused !== null && paused !== undefined)
+            lines.push(`**Paused:** ${paused}`);
+    }
+    lines.push("");
+    const outgoingMap = new Map();
+    for (const edge of edges) {
+        if (edge.from === "")
+            continue;
+        if (!outgoingMap.has(edge.from))
+            outgoingMap.set(edge.from, []);
+        outgoingMap.get(edge.from).push(edge);
+    }
+    const terminalNodes = new Set();
+    for (const node of nodes) {
+        const outEdges = outgoingMap.get(node.name) ?? [];
+        const hasOutgoingToNode = outEdges.some(e => e.to !== "");
+        if (!hasOutgoingToNode) {
+            const isTargeted = edges.some(e => e.to === node.name);
+            if (isTargeted)
+                terminalNodes.add(node.name);
+        }
+    }
+    for (const edge of edges) {
+        const fromLabel = edge.from === "" ? "[*]" : edge.from;
+        const toLabel = edge.to === "" ? "[*]" : edge.to;
+        const isCycle = edge.from === edge.to && edge.from !== "";
+        const cycleStr = isCycle ? " (cycle)" : "";
+        const terminalStr = terminalNodes.has(edge.to) ? " (terminal)" : "";
+        lines.push(`## ${fromLabel} → ${toLabel}${cycleStr}${terminalStr}`);
+        for (const fwd of edge.forwards) {
+            const parts = [`weight=${fwd.weight}`];
+            if (fwd.named_operator !== null && fwd.named_operator !== undefined) {
+                parts.push(`namedOperator='${fwd.named_operator}'`);
+            }
+            if (fwd.permission_index !== null && fwd.permission_index !== undefined) {
+                parts.push(`permissionIndex=${fwd.permission_index}`);
+            }
+            if (fwd.guard) {
+                parts.push(`guard=${fwd.guard}`);
+            }
+            if (edge.threshold > 1) {
+                parts.push(`threshold=${edge.threshold}`);
+            }
+            lines.push(`### forward: ${fwd.name} (${parts.join(", ")})`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/knowledge/machine-risk.js

@@ -123,7 +123,10 @@ export const MACHINE_RISK_RULES = [
             "dispute in the machine (e.g., 'disputed → refunded' forward guarded " +
             "by Permission index 1500) create dead-end paths because no one has " +
             "Permission 1500 — arbitrators are NOT Permission holders.",
-        detection: "Match node names against regex /^(disputed|refunded|arb|arbitration|dispute|refund)$/i",
+        detection: "Match node names against regex /(^|_)(disputed?|refund(?:ed)?|arbitration|arb)(_|$)/i " +
+            "(catches both exact names like 'refunded' and compound fund-flow terminals like " +
+            "'deposit_refunded'/'deposit_deducted'; business states like 'return_approved'/" +
+            "'damage_confirmed'/'cancelled'/'returned' do NOT match)",
         recommendation: "Remove all dispute/refund nodes from the machine. Instead: (1) bind an " +
             "Arbitration object to the Service via Service.arbitrations, (2) configure " +
             "arbitrators via Arbitration.voting_guard_add, (3) deposit compensation_fund " +

package/dist/knowledge/machine-templates.js

@@ -1016,7 +1016,7 @@ export const MACHINE_TEMPLATES = [
                 type: "string",
                 required: true,
                 default: "wonder",
-                description: "Node name for positive feedback (好评) terminal",
+                description: "Node name for positive feedback (praise) terminal",
                 constraint: "Must match /^(wonder|praise|thumbs_up)$/i OR be a custom name; must NOT match dispute anti-pattern regex",
             },
             {
@@ -1024,7 +1024,7 @@ export const MACHINE_TEMPLATES = [
                 type: "string",
                 required: true,
                 default: "no_wonder",
-                description: "Node name for negative feedback (差评) terminal",
+                description: "Node name for negative feedback (complaint) terminal",
                 constraint: "Must match /^(no_wonder|complain|thumbs_down)$/i OR be a custom name; must NOT match dispute anti-pattern regex",
             },
             {
@@ -1047,8 +1047,8 @@ export const MACHINE_TEMPLATES = [
             { name: "Shipped", description: "Merchant dispatched goods/service" },
             { name: "Received", description: "Customer confirmed receipt" },
             { name: "Completed", description: "Terminal business state — triggers merchant Allocation. Funds settled." },
-            { name: "${wonder_node_name}", description: "Positive feedback terminal (好评). OrderHolder-only. Reward-eligible." },
-            { name: "${no_wonder_node_name}", description: "Negative feedback terminal (差评). OrderHolder-only. Optional Repository write for analytics." },
+            { name: "${wonder_node_name}", description: "Positive feedback terminal (praise). OrderHolder-only. Reward-eligible." },
+            { name: "${no_wonder_node_name}", description: "Negative feedback terminal (complaint). OrderHolder-only. Optional Repository write for analytics." },
         ],
         example_pairs: [
             {

package/dist/knowledge/progress-context.js

@@ -336,7 +336,7 @@ export function buildPromptFromProgressContext(bundle) {
     }
     if (h.include_terminal_node_note) {
         lines.push("─ Terminal Node Note ──────────────");
-        lines.push("At terminal nodes (completed/enforced/deposit_refunded/paid), use progress::owner_receive");
+        lines.push("At terminal nodes (completed/enforced/return_approved/paid), use progress::owner_receive");
         lines.push("to unwrap Receiving<K> / CoinWrapper<T> via Payment.unwrap_with_check.");
         lines.push("Permission 225 (PROGRESS_OWNER_RECEIVE) required; recipient = Machine.permission owner.");
         lines.push("");

package/dist/knowledge/progress-ledger.js

@@ -177,7 +177,7 @@ export const PROGRESS_SCENES = [
         industry: ["finance", "treasury", "rental", "freelance"],
         scenario: "Owner receives Receiving<K> objects or CoinWrapper<T> coins sent to the Progress object. " +
             "unwrap → permission::owner_receive_inner forwards to Permission owner. " +
-            "Used at terminal nodes (deposit_refunded, completed, enforced) to disburse funds.",
+            "Used at terminal nodes (return_approved, completed, enforced) to disburse funds.",
         phases: ["owner_receive"],
         requires_published_machine: true,
         requires_order_bound: true,
@@ -189,7 +189,7 @@ export const PROGRESS_SCENES = [
         common_patterns: [
             "owner_receive unwraps CoinWrapper<T> via Payment.unwrap_with_check (amount validation)",
             "owner_receive_object receives a generic K:key+store object and forwards to Permission owner",
-            "Triggered at terminal nodes (e.g. 'deposit_refunded' in rental, 'enforced' in arbitration)",
+            "Triggered at terminal nodes (e.g. 'return_approved' in rental, 'enforced' in arbitration)",
             "Permission owner ≠ Progress creator: receives flow to whoever owns the bound Machine's Permission",
         ],
         recommended_templates: ["T-PR-06"],
@@ -326,5 +326,5 @@ export const PROGRESS_CROSS_OBJECT_REFS = [
     { object: "Passport", phase: "forward_advance", relationship: "Forward.guard (Some) requires Passport + passport::result_for_guard" },
     { object: "Passport", phase: "unhold_state", relationship: "unhold_with_passport: 224 check via passport (fallback when sender_has_permission_idcheck fails)" },
     { object: "Payment", phase: "owner_receive", relationship: "owner_receive unwraps CoinWrapper<T> via Payment.unwrap_with_check" },
-    { object: "Allocation", phase: "completed", relationship: "Terminal node triggers Allocation alloc (e.g. 'completed', 'enforced', 'deposit_refunded')" },
+    { object: "Allocation", phase: "completed", relationship: "Terminal node triggers Allocation alloc (e.g. 'completed', 'enforced', 'return_approved')" },
 ];

package/dist/knowledge/progress-templates.js

@@ -184,7 +184,7 @@ export const PROGRESS_TEMPLATES = [
         notes: [
             "Permission 225 (PROGRESS_OWNER_RECEIVE) is required; SDK CallProgress_Data does NOT expose this op",
             "Recipient is Permission owner (Machine.permission's owner), NOT Progress creator",
-            "Triggered at terminal nodes: 'deposit_refunded', 'completed', 'enforced', 'paid'",
+            "Triggered at terminal nodes: 'return_approved', 'completed', 'enforced', 'paid'",
             "For coins: Payment.unwrap_with_check validates amount before forwarding to owner",
             "For objects: generic K:key+store — forwarded directly via permission::owner_receive_inner",
         ],

package/dist/knowledge/progress-translation.js

@@ -128,7 +128,7 @@ export const PROGRESS_SEMANTIC_TO_SCHEMA_RULES = [
             arguments: ["progress", "machine", "permission", "received", "payment"],
         },
         reverse_explanation: "Calls progress::owner_receive (225 permission). Unwraps CoinWrapper<T> via Payment.unwrap_with_check, " +
-            "forwards coin/object to Permission owner. Typically triggered at terminal nodes (deposit_refunded, completed, enforced).",
+            "forwards coin/object to Permission owner. Typically triggered at terminal nodes (return_approved, completed, enforced).",
     },
 ];
 export const PROGRESS_SCHEMA_TO_SEMANTIC_RULES = [

package/dist/knowledge/reward-confirm.js

@@ -137,7 +137,7 @@ function runStaticChecklist(input) {
     const cr11 = items.find(i => i.id === "C-R-11");
     if (data.guard_expected_progress_state && input.user_intent_phrases && input.user_intent_phrases.length > 0) {
         const intentLower = input.user_intent_phrases.join(" ").toLowerCase();
-        const praiseKeywords = ["好评", "praise", "wonder", "thumbs_up", "positive review", "satisfaction reward", "好评奖励"];
+        const praiseKeywords = ["praise", "wonder", "thumbs_up", "positive review", "satisfaction reward", "praise reward"];
         const isPraiseIntent = praiseKeywords.some(kw => intentLower.includes(kw.toLowerCase()));
         if (isPraiseIntent && input.machine_has_wonder_node !== false && data.guard_expected_progress_state !== "wonder") {
             cr11.passed = false;
@@ -224,7 +224,7 @@ export const REWARD_CONFIRMATION_QUESTIONS = [
     {
         id: "QRW7",
         question: "⚠️ For guard_add with progress.current check: does the Guard's expected progress node match the business intent? " +
-            "If intent is '好评/praise', Guard must check 'wonder' (NOT 'completed'). " +
+            "If intent is 'praise/positive review', Guard must check 'wonder' (NOT 'completed'). " +
             "Premature claim at wrong node drains reward pool — Guard is immutable after creation.",
         requires_explicit_yes: true,
         related_risk_ids: ["R-R-6-01", "R-R-6-02"],