@wowok/agent-mcp 2.5.5 → 2.6.1

package/dist/project/evaluation.js

@@ -1,9 +1,9 @@
+import { IndustryModeRegistry } from "../extensions/registry.js";
 const CRITICAL_BINDINGS = [
     { sourceType: "Service", targetType: "Machine", fieldName: "machine", critical: true },
     { sourceType: "Service", targetType: "Permission", fieldName: "permission", critical: true },
     { sourceType: "Service", targetType: "Guard", fieldName: "buy_guard", critical: false },
-    { sourceType: "Service", targetType: "Treasury", fieldName: "compensation_fund", critical: false },
-    { sourceType: "Service", targetType: "Allocation", fieldName: "order_allocators", critical: false },
+    { sourceType: "Service", targetType: "Allocation", fieldName: "order_allocators", critical: true },
     { sourceType: "Service", targetType: "Arbitration", fieldName: "arbitrations", critical: false },
     { sourceType: "Machine", targetType: "Permission", fieldName: "permission", critical: true },
 ];
@@ -11,21 +11,47 @@ const MERCHANT_REQUIRED_ITEMS = [
     { id: "R1", objectType: "Permission", fieldName: "", required: true, description: "Governance — who can manage the service" },
     { id: "R2", objectType: "Service", fieldName: "", required: true, description: "Core offering — the service itself" },
     { id: "R3", objectType: "Machine", fieldName: "machine", required: true, description: "Workflow — order processing pipeline" },
-    { id: "R4", objectType: "Guard", fieldName: "buy_guard", required: true, description: "Purchase validation — guard on Service.buy()" },
-    { id: "R5", objectType: "Allocation", fieldName: "order_allocators", required: true, description: "Order allocators — fund distribution rules" },
-    { id: "R6", objectType: "Treasury", fieldName: "compensation_fund", required: true, description: "Compensation fund — buyer refund protection" },
-    { id: "R7", objectType: "Arbitration", fieldName: "arbitrations", required: true, description: "Dispute resolution — arbitration configured" },
+    { id: "R4", objectType: "Guard", fieldName: "", required: true, description: "Purchase validation — Guard objects configured (binding to Service.buy_guard is optional)" },
+    { id: "R5", objectType: "Allocation", fieldName: "order_allocators", required: true, description: "Order allocators template — inline Allocators on Service (independent Allocation objects are created per-order)" },
+    { id: "R6", objectType: "Treasury", fieldName: "", required: true, description: "Compensation fund — independent Treasury object for buyer refund protection (industry-aware: optional for freelance)" },
+    { id: "R7", objectType: "Arbitration", fieldName: "arbitrations", required: true, description: "Dispute resolution — arbitration configured (required when compensation_fund > 0 per service.move:494)" },
     { id: "R8", objectType: "Contact", fieldName: "", required: true, description: "Customer communication — contact info" },
     { id: "R9", objectType: "Progress", fieldName: "", required: false, description: "Order tracking — progress nodes" },
     { id: "R10", objectType: "Reward", fieldName: "rewards", required: false, description: "Customer incentives — reward claims" },
     { id: "R11", objectType: "Repository", fieldName: "repositories", required: false, description: "Documentation — published data" },
     { id: "R12", objectType: "Demand", fieldName: "", required: false, description: "Market discovery — demand signals" },
 ];
+function resolveRequiredItems(industry, compensationFundBalance = 0) {
+    let result = MERCHANT_REQUIRED_ITEMS;
+    if (industry && industry !== "general") {
+        let mode;
+        try {
+            mode = IndustryModeRegistry.Instance().getMode(industry);
+        }
+        catch {
+        }
+        if (mode) {
+            const requireFund = mode.risk_constraints?.require_compensation_fund ?? true;
+            if (!requireFund) {
+                result = MERCHANT_REQUIRED_ITEMS.map(item => {
+                    if (item.id === "R6" || item.id === "R7") {
+                        return { ...item, required: false };
+                    }
+                    return item;
+                });
+            }
+        }
+    }
+    if (compensationFundBalance > 0) {
+        result = result.map(item => item.id === "R7" ? { ...item, required: true } : item);
+    }
+    return result;
+}
 const CONSUMER_DUE_DILIGENCE = [
     { id: "E1", check: "Service is published (bPublished=true)", severity: "critical", deduction: -30 },
     { id: "E2", check: "Service is not paused (bPaused=false)", severity: "warning", deduction: -20 },
     { id: "E3", check: "Machine has workflow nodes", severity: "warning", deduction: -15 },
-    { id: "E4", check: "Service has buy_guard (purchase validation)", severity: "warning", deduction: -15 },
+    { id: "E4", check: "Service has buy_guard (purchase validation)", severity: "info", deduction: 0 },
     { id: "E5", check: "Service has compensation_fund (refund protection)", severity: "warning", deduction: -15 },
     { id: "E6", check: "Arbitration is configured (dispute resolution)", severity: "critical", deduction: -25 },
     { id: "E7", check: "Permission is present (governance)", severity: "warning", deduction: -10 },
@@ -34,11 +60,21 @@ const CONSUMER_DUE_DILIGENCE = [
     { id: "E10", check: "Reward is configured (customer incentives)", severity: "info", deduction: -3 },
     { id: "E11", check: "Service has description (offering clarity)", severity: "info", deduction: -5 },
     { id: "E12", check: "Registrar reputation is positive", severity: "warning", deduction: -10 },
-    { id: "E13", check: "No critical findings in risk evaluation", severity: "critical", deduction: -20 },
 ];
 function clampScore(n) {
     return Math.max(0, Math.min(100, Math.round(n)));
 }
+function shortTypeName(objectType) {
+    if (!objectType)
+        return "unknown";
+    const base = objectType.replace(/<.*>/, "").trim();
+    const segments = base.split("::");
+    const shortName = segments[segments.length - 1] || "unknown";
+    if (shortName.length > 0 && shortName === shortName.toLowerCase()) {
+        return shortName.charAt(0).toUpperCase() + shortName.slice(1);
+    }
+    return shortName;
+}
 function parseCacheData(cached) {
     if (!cached)
         return null;
@@ -58,6 +94,104 @@ function countArrayField(data, field) {
         return v.length;
     return 0;
 }
+export function getNumberField(data, field) {
+    if (!data)
+        return 0;
+    const v = data[field];
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    if (typeof v === "string") {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return 0;
+}
+export function getMachineNodeCount(data) {
+    if (!data)
+        return 0;
+    const nc = getNumberField(data, "node_count");
+    if (nc > 0)
+        return nc;
+    const arrLen = countArrayField(data, "nodes");
+    if (arrLen > 0)
+        return arrLen;
+    const nodesObj = data["nodes"];
+    if (nodesObj && typeof nodesObj === "object") {
+        const fieldsObj = nodesObj["fields"];
+        if (fieldsObj && typeof fieldsObj === "object") {
+            const sizeVal = getNumberField(fieldsObj, "size");
+            if (sizeVal > 0)
+                return sizeVal;
+        }
+        const directSize = getNumberField(nodesObj, "size");
+        if (directSize > 0)
+            return directSize;
+    }
+    return 0;
+}
+function getBalanceValue(data, field) {
+    if (!data)
+        return 0;
+    const v = data[field];
+    if (v == null)
+        return 0;
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    if (typeof v === "string") {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    if (typeof v === "object") {
+        const obj = v;
+        const inner = obj.value ?? obj.fields;
+        if (typeof inner === "number" && Number.isFinite(inner))
+            return inner;
+        if (typeof inner === "string") {
+            const n = Number(inner);
+            if (Number.isFinite(n))
+                return n;
+        }
+        if (typeof inner === "object" && inner !== null) {
+            const innerObj = inner;
+            const val = innerObj.value;
+            if (typeof val === "number" && Number.isFinite(val))
+                return val;
+            if (typeof val === "string") {
+                const n = Number(val);
+                if (Number.isFinite(n))
+                    return n;
+            }
+        }
+    }
+    return 0;
+}
+function getMaxSalePrice(data) {
+    if (!data)
+        return 0;
+    const sales = data.sales;
+    if (!Array.isArray(sales) || sales.length === 0)
+        return 0;
+    let max = 0;
+    for (const sale of sales) {
+        if (typeof sale !== "object" || sale === null)
+            continue;
+        const price = sale.price;
+        let n = 0;
+        if (typeof price === "number" && Number.isFinite(price)) {
+            n = price;
+        }
+        else if (typeof price === "string") {
+            const parsed = Number(price);
+            if (Number.isFinite(parsed))
+                n = parsed;
+        }
+        if (n > max)
+            max = n;
+    }
+    return max;
+}
 function detectCircularRefs(edges) {
     const adj = new Map();
     for (const e of edges) {
@@ -71,14 +205,36 @@ function detectCircularRefs(edges) {
     const visited = new Set();
     const recursionStack = new Set();
     const path = [];
-    const dfs = (node) => {
-        visited.add(node);
-        recursionStack.add(node);
-        path.push(node);
-        const neighbors = adj.get(node) ?? [];
-        for (const neighbor of neighbors) {
+    for (const startNode of adj.keys()) {
+        if (visited.has(startNode))
+            continue;
+        const stack = [{
+                node: startNode,
+                nextNeighborIdx: 0,
+                neighbors: adj.get(startNode) ?? [],
+            }];
+        visited.add(startNode);
+        recursionStack.add(startNode);
+        path.push(startNode);
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            if (frame.nextNeighborIdx >= frame.neighbors.length) {
+                stack.pop();
+                path.pop();
+                recursionStack.delete(frame.node);
+                continue;
+            }
+            const neighbor = frame.neighbors[frame.nextNeighborIdx];
+            frame.nextNeighborIdx++;
             if (!visited.has(neighbor)) {
-                dfs(neighbor);
+                visited.add(neighbor);
+                recursionStack.add(neighbor);
+                path.push(neighbor);
+                stack.push({
+                    node: neighbor,
+                    nextNeighborIdx: 0,
+                    neighbors: adj.get(neighbor) ?? [],
+                });
             }
             else if (recursionStack.has(neighbor)) {
                 const cycleStart = path.indexOf(neighbor);
@@ -86,12 +242,6 @@ function detectCircularRefs(edges) {
                 cycles.push(cycle.join("→"));
             }
         }
-        path.pop();
-        recursionStack.delete(node);
-    };
-    for (const node of adj.keys()) {
-        if (!visited.has(node))
-            dfs(node);
     }
     return cycles;
 }
@@ -138,15 +288,171 @@ function buildBindingIndex(edges) {
             idx.set(key, new Set());
         idx.get(key).add(e.targetObject);
     }
+    for (const e of edges) {
+        if (e.edgeSource !== "potential")
+            continue;
+        if (!e.fieldName)
+            continue;
+        const key = `${e.sourceObject}#${e.fieldName}`;
+        if (!idx.has(key) || idx.get(key).size === 0) {
+            if (!idx.has(key))
+                idx.set(key, new Set());
+            idx.get(key).add(e.targetObject);
+        }
+    }
     return idx;
 }
+function evaluateIndustryPattern(project, objects, objectCache, edges) {
+    const result = { strengths: [], findings: [], matched: false };
+    const industryName = project.industry;
+    if (!industryName || industryName === "general") {
+        return result;
+    }
+    let mode;
+    try {
+        mode = IndustryModeRegistry.Instance().getMode(industryName);
+    }
+    catch {
+        return result;
+    }
+    if (!mode)
+        return result;
+    const byType = new Map();
+    for (const obj of objects) {
+        const t = shortTypeName(obj.objectType);
+        if (!byType.has(t))
+            byType.set(t, []);
+        byType.get(t).push(obj);
+    }
+    const bindingIndex = buildBindingIndex(edges);
+    let matchCount = 0;
+    let totalChecks = 0;
+    const expectedNodes = mode.machine_shape;
+    if (expectedNodes.length > 0) {
+        totalChecks++;
+        const machines = byType.get("Machine") ?? [];
+        if (machines.length > 0) {
+            const machineObj = machines[0];
+            const cached = parseCacheData(objectCache.get(machineObj.objectAddress));
+            const nodeCount = getNumberField(cached, "node_count") || countArrayField(cached ?? {}, "nodes");
+            if (nodeCount > 0 && nodeCount >= expectedNodes.length) {
+                matchCount++;
+                result.strengths.push(`Industry pattern match: Machine has ${nodeCount} nodes, covering "${industryName}" mode's ${expectedNodes.length} expected node(s)`);
+            }
+            else if (nodeCount > 0) {
+                result.findings.push({
+                    criterion: "industry_pattern",
+                    severity: "info",
+                    message: `Industry pattern: Machine has ${nodeCount} nodes, but "${industryName}" mode expects at least ${expectedNodes.length}`,
+                    deduction: 0,
+                });
+            }
+        }
+    }
+    const expectedGuards = mode.guards;
+    if (expectedGuards.length > 0) {
+        totalChecks++;
+        const guards = byType.get("Guard") ?? [];
+        const minGuards = expectedGuards.length;
+        const maxGuards = expectedGuards.length * 2;
+        if (guards.length >= minGuards && guards.length <= maxGuards) {
+            matchCount++;
+            result.strengths.push(`Industry pattern match: ${guards.length} Guard(s) present, within "${industryName}" mode's expected range [${minGuards}-${maxGuards}]`);
+        }
+        else if (guards.length > 0 && guards.length < minGuards) {
+            result.findings.push({
+                criterion: "industry_pattern",
+                severity: "info",
+                message: `Industry pattern: ${guards.length} Guard(s) present, but "${industryName}" mode expects at least ${minGuards} (recommended range [${minGuards}-${maxGuards}])`,
+                deduction: 0,
+            });
+        }
+        else if (guards.length > maxGuards) {
+            matchCount++;
+            result.strengths.push(`Industry pattern match: ${guards.length} Guard(s) present, covering "${industryName}" mode's ${minGuards} expected guard(s)`);
+            result.findings.push({
+                criterion: "industry_pattern",
+                severity: "info",
+                message: `Industry pattern: ${guards.length} Guard(s) present, exceeds recommended max ${maxGuards}. Consider consolidating guards if some are redundant.`,
+                deduction: 0,
+            });
+        }
+    }
+    const expectedAllocStrategy = mode.allocator;
+    if (expectedAllocStrategy) {
+        totalChecks++;
+        const allocations = byType.get("Allocation") ?? [];
+        const services4Alloc = byType.get("Service") ?? [];
+        const serviceForAlloc = services4Alloc[0];
+        const hasOrderAllocators = serviceForAlloc
+            ? !!bindingIndex.get(`${serviceForAlloc.objectAddress}#order_allocators`)?.size
+            : false;
+        const expectsMultiple = mode.traits.multi_tier_allocation;
+        if (hasOrderAllocators) {
+            matchCount++;
+            if (allocations.length > 0) {
+                result.strengths.push(`Industry pattern match: Service.order_allocators bound + ${allocations.length} Allocation object(s) present (post-order) — matching "${industryName}" allocation pattern`);
+            }
+            else {
+                result.strengths.push(`Industry pattern match: Service.order_allocators template bound — matching "${industryName}" allocation pattern (Allocation objects created per-order)`);
+            }
+        }
+        else if (allocations.length > 0) {
+            matchCount++;
+            result.strengths.push(`Industry pattern match: ${allocations.length} Allocation object(s) present — matching "${industryName}" allocation pattern`);
+        }
+        else {
+            result.findings.push({
+                criterion: "industry_pattern",
+                severity: "info",
+                message: `Industry pattern: Service.order_allocators not bound and no Allocation objects — "${industryName}" mode expects ${expectsMultiple ? "multi-tier" : "single-tier"} allocation (Allocation objects are created per-order, so this is only a template-level gap)`,
+                deduction: 0,
+            });
+        }
+    }
+    const requireCompensationFund = mode.risk_constraints?.require_compensation_fund ?? false;
+    if (requireCompensationFund || mode.traits.deposit_required || mode.traits.trust_sensitivity !== "low") {
+        totalChecks++;
+        const treasuries = byType.get("Treasury") ?? [];
+        const services4Treas = byType.get("Service") ?? [];
+        const serviceForTreas = services4Treas[0];
+        const serviceDataForTreas = serviceForTreas
+            ? parseCacheData(objectCache.get(serviceForTreas.objectAddress))
+            : null;
+        const compensationBalance = serviceForTreas
+            ? getBalanceValue(serviceDataForTreas, "compensation_fund")
+            : 0;
+        if (treasuries.length > 0 || compensationBalance > 0) {
+            matchCount++;
+            const parts = [];
+            if (treasuries.length > 0)
+                parts.push(`${treasuries.length} Treasury object(s)`);
+            if (compensationBalance > 0)
+                parts.push(`compensation_fund balance ${compensationBalance}`);
+            result.strengths.push(`Industry pattern match: ${parts.join(" + ")} — matching "${industryName}" trust/deposit pattern`);
+        }
+    }
+    result.matched = totalChecks > 0 && matchCount / totalChecks >= 0.6;
+    if (result.matched) {
+        result.strengths.push(`Industry pattern: project structure matches "${industryName}" mode (${matchCount}/${totalChecks} checks passed)`);
+    }
+    else if (totalChecks > 0) {
+        result.findings.push({
+            criterion: "industry_pattern",
+            severity: "info",
+            message: `Industry pattern: project partially matches "${industryName}" mode (${matchCount}/${totalChecks} checks passed)`,
+            deduction: 0,
+        });
+    }
+    return result;
+}
 function evaluateRisk(input) {
     const findings = [];
     const strengths = [];
     const { objects, edges, objectCache, project } = input;
     const byType = new Map();
     for (const obj of objects) {
-        const t = obj.objectType ?? "unknown";
+        const t = shortTypeName(obj.objectType);
         if (!byType.has(t))
             byType.set(t, []);
         byType.get(t).push(obj);
@@ -155,19 +461,24 @@ function evaluateRisk(input) {
     const bindingIndex = buildBindingIndex(edges);
     let structuralScore = 100;
     const serviceObj = services[0];
+    const svcDataForStruct = serviceObj ? parseCacheData(objectCache.get(serviceObj.objectAddress)) : null;
+    const compensationBalanceForStruct = serviceObj ? getBalanceValue(svcDataForStruct, "compensation_fund") : 0;
     if (serviceObj) {
         for (const expected of CRITICAL_BINDINGS) {
             if (expected.sourceType !== "Service")
                 continue;
+            const effectiveCritical = expected.fieldName === "arbitrations"
+                ? (compensationBalanceForStruct > 0 ? true : expected.critical)
+                : expected.critical;
             const key = `${serviceObj.objectAddress}#${expected.fieldName}`;
             const bindings = bindingIndex.get(key);
             if (!bindings || bindings.size === 0) {
-                const deduction = expected.critical ? -25 : -10;
+                const deduction = effectiveCritical ? -25 : -10;
                 structuralScore += deduction;
                 findings.push({
                     criterion: "structural_risk",
-                    severity: expected.critical ? "critical" : "warning",
-                    message: `Service missing ${expected.fieldName} binding (expected ${expected.targetType})`,
+                    severity: effectiveCritical ? "critical" : "warning",
+                    message: `Service missing ${expected.fieldName} binding (expected ${expected.targetType})${expected.fieldName === "arbitrations" ? (compensationBalanceForStruct > 0 ? " — required by contract when compensation_fund > 0 (service.move:494)" : " — optional when compensation_fund is 0") : ""}`,
                     deduction,
                 });
             }
@@ -188,27 +499,72 @@ function evaluateRisk(input) {
     structuralScore = clampScore(structuralScore);
     let fundScore = 100;
     const treasuries = byType.get("Treasury") ?? [];
-    if (treasuries.length === 0) {
-        fundScore -= 30;
-        findings.push({
-            criterion: "fund_safety",
-            severity: "warning",
-            message: "No Treasury object — no compensation fund for refunds",
-            deduction: -30,
-        });
-    }
-    else {
-        strengths.push(`${treasuries.length} Treasury object(s) present`);
+    const serviceData = serviceObj ? parseCacheData(objectCache.get(serviceObj.objectAddress)) : null;
+    const compensationBalance = serviceObj ? getBalanceValue(serviceData, "compensation_fund") : 0;
+    let industryRequiresFund = true;
+    if (project.industry && project.industry !== "general") {
+        try {
+            const mode = IndustryModeRegistry.Instance().getMode(project.industry);
+            if (mode) {
+                industryRequiresFund = mode.risk_constraints?.require_compensation_fund ?? true;
+            }
+        }
+        catch { }
     }
-    if (serviceObj) {
-        const cfKey = `${serviceObj.objectAddress}#compensation_fund`;
-        if (!bindingIndex.get(cfKey)?.size) {
-            fundScore -= 20;
+    if (treasuries.length === 0 && compensationBalance === 0) {
+        if (industryRequiresFund) {
+            fundScore -= 30;
             findings.push({
                 criterion: "fund_safety",
                 severity: "warning",
-                message: "Service compensation_fund not bound — buyer refunds unprotected",
-                deduction: -20,
+                message: "No Treasury object and Service.compensation_fund is empty — no refund fund for buyers",
+                deduction: -30,
+            });
+        }
+        else {
+            fundScore -= 10;
+            findings.push({
+                criterion: "fund_safety",
+                severity: "info",
+                message: `No Treasury/compensation_fund — industry "${project.industry}" does not require refund fund (optional)`,
+                deduction: -10,
+            });
+        }
+    }
+    else {
+        if (treasuries.length > 0) {
+            strengths.push(`${treasuries.length} Treasury object(s) present — independent fund holder`);
+        }
+        if (compensationBalance > 0) {
+            strengths.push(`Service.compensation_fund has ${compensationBalance} units — inline refund fund active`);
+            const maxSalePrice = getMaxSalePrice(serviceData);
+            if (maxSalePrice > 0) {
+                const requiredThreshold = 5 * maxSalePrice;
+                if (compensationBalance < requiredThreshold) {
+                    fundScore -= 10;
+                    findings.push({
+                        criterion: "fund_safety",
+                        severity: "warning",
+                        message: `Service.compensation_fund balance (${compensationBalance}) is less than 5× the max order amount (${maxSalePrice} → threshold ${requiredThreshold}). Refund coverage may be insufficient — top up via service.compensation_fund_add to avoid arbitration rulings exceeding the fund.`,
+                        deduction: -10,
+                    });
+                }
+                else {
+                    findings.push({
+                        criterion: "fund_safety",
+                        severity: "info",
+                        message: `Service.compensation_fund balance (${compensationBalance}) covers 5× the max order amount (${maxSalePrice}). Fund is sufficient for refund protection.`,
+                        deduction: 0,
+                    });
+                }
+            }
+        }
+        else {
+            findings.push({
+                criterion: "fund_safety",
+                severity: "info",
+                message: "Treasury present but Service.compensation_fund balance is 0 — consider depositing refund fund",
+                deduction: -5,
             });
         }
     }
@@ -267,18 +623,27 @@ function evaluateRisk(input) {
     if (serviceObj) {
         const data = parseCacheData(objectCache.get(serviceObj.objectAddress));
         if (data && !isAddress(data.um)) {
-            governanceScore -= 15;
+            governanceScore -= 5;
             findings.push({
                 criterion: "governance_risk",
-                severity: "warning",
-                message: "Service has no UM (manager) — cannot be managed on-chain",
-                deduction: -15,
+                severity: "info",
+                message: "Service has no UM (manager) — UM is optional; set via um_set if management delegation needed",
+                deduction: -5,
             });
         }
     }
     governanceScore = clampScore(governanceScore);
     let coherenceScore = 100;
-    const objectAddresses = new Set(objects.map(o => o.objectAddress));
+    const objectAddresses = new Set();
+    for (const o of objects) {
+        if (o.objectAddress)
+            objectAddresses.add(o.objectAddress);
+        if (o.objectName) {
+            objectAddresses.add(o.objectName);
+            const shortType = shortTypeName(o.objectType).toLowerCase();
+            objectAddresses.add(`${shortType}:${o.objectName}`);
+        }
+    }
     let danglingCount = 0;
     for (const e of edges) {
         if (e.edgeSource === "potential")
@@ -340,7 +705,7 @@ function evaluateTrust(input) {
     const { objects, edges, objectCache, reputation, project } = input;
     const byType = new Map();
     for (const obj of objects) {
-        const t = obj.objectType ?? "unknown";
+        const t = shortTypeName(obj.objectType);
         if (!byType.has(t))
             byType.set(t, []);
         byType.get(t).push(obj);
@@ -416,15 +781,10 @@ function evaluateTrust(input) {
         const bgKey = `${services[0].objectAddress}#buy_guard`;
         if (bindingIndex.get(bgKey)?.size) {
             guardScore = clampScore(guardScore + 15);
-            strengths.push("Service has buy_guard — purchase validation active");
+            strengths.push("Service has buy_guard bound — purchase validation active");
         }
-        else {
-            findings.push({
-                criterion: "guard_quality",
-                severity: "warning",
-                message: "Service buy_guard not bound — unvalidated purchases",
-                deduction: -15,
-            });
+        else if (guards.length > 0) {
+            strengths.push("Guard objects present (buy_guard binding optional)");
         }
     }
     guardScore = clampScore(guardScore);
@@ -484,14 +844,16 @@ function evaluateTrust(input) {
                 case "E3":
                     passed = (byType.get("Machine") ?? []).some(m => {
                         const d = parseCacheData(objectCache.get(m.objectAddress));
-                        return d && (countArrayField(d, "nodes") > 0);
+                        return d && (getNumberField(d, "node_count") > 0 || countArrayField(d, "nodes") > 0);
                     });
                     break;
                 case "E4":
-                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#buy_guard`)?.size;
+                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#buy_guard`)?.size
+                        || (byType.get("Guard") ?? []).length > 0;
                     break;
                 case "E5":
-                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#compensation_fund`)?.size;
+                    passed = getBalanceValue(svcData, "compensation_fund") > 0
+                        || (byType.get("Treasury") ?? []).length > 0;
                     break;
                 case "E6":
                     passed = (byType.get("Arbitration") ?? []).length > 0;
@@ -517,20 +879,32 @@ function evaluateTrust(input) {
                         passed = !!rep && rep.likes >= rep.dislikes;
                     }
                     break;
-                case "E13":
-                    passed = true;
-                    break;
             }
             if (passed) {
                 diligencePassed.push(check.id);
             }
             else {
-                diligenceScore += check.deduction;
+                let effectiveDeduction = check.deduction;
+                let effectiveSeverity = check.severity;
+                if (check.id === "E5" && project.industry && project.industry !== "general") {
+                    try {
+                        const mode = IndustryModeRegistry.Instance().getMode(project.industry);
+                        if (mode && mode.risk_constraints?.require_compensation_fund === false) {
+                            effectiveDeduction = -3;
+                            effectiveSeverity = "info";
+                        }
+                    }
+                    catch { }
+                }
+                diligenceScore += effectiveDeduction;
+                const detailSuffix = check.id === "E5" && effectiveDeduction !== check.deduction
+                    ? " (industry does not require compensation_fund — reduced deduction)"
+                    : "";
                 findings.push({
                     criterion: "consumer_diligence",
-                    severity: check.severity,
-                    message: `${check.id}: ${check.check} — FAILED`,
-                    deduction: check.deduction,
+                    severity: effectiveSeverity,
+                    message: `${check.id}: ${check.check} — FAIL: condition not met${detailSuffix} [severity: ${effectiveSeverity}]`,
+                    deduction: effectiveDeduction,
                 });
             }
         }
@@ -578,14 +952,19 @@ function evaluateCompleteness(input) {
     const { objects, edges, objectCache, project } = input;
     const byType = new Map();
     for (const obj of objects) {
-        const t = obj.objectType ?? "unknown";
+        const t = shortTypeName(obj.objectType);
         if (!byType.has(t))
             byType.set(t, []);
         byType.get(t).push(obj);
     }
     const services = byType.get("Service") ?? [];
     const bindingIndex = buildBindingIndex(edges);
-    const requiredItems = MERCHANT_REQUIRED_ITEMS;
+    const svcObjForRequiredItems = services[0];
+    const svcDataForRequiredItems = svcObjForRequiredItems
+        ? parseCacheData(objectCache.get(svcObjForRequiredItems.objectAddress))
+        : null;
+    const compensationBalanceForItems = getBalanceValue(svcDataForRequiredItems, "compensation_fund");
+    const requiredItems = resolveRequiredItems(project.industry ?? undefined, compensationBalanceForItems);
     const requiredCount = requiredItems.filter(r => r.required).length;
     const optionalItems = requiredItems.filter(r => !r.required);
     let requiredMet = 0;
@@ -643,23 +1022,28 @@ function evaluateCompleteness(input) {
     let bindingScore = 100;
     if (services[0]) {
         const serviceAddr = services[0].objectAddress;
+        const svcDataForBind = parseCacheData(objectCache.get(serviceAddr));
+        const compensationBalanceForBind = getBalanceValue(svcDataForBind, "compensation_fund");
         let boundCount = 0;
         let totalCount = 0;
         for (const expected of CRITICAL_BINDINGS) {
             if (expected.sourceType !== "Service")
                 continue;
             totalCount++;
+            const effectiveCritical = expected.fieldName === "arbitrations"
+                ? (compensationBalanceForBind > 0 ? true : expected.critical)
+                : expected.critical;
             const key = `${serviceAddr}#${expected.fieldName}`;
             if (bindingIndex.get(key)?.size) {
                 boundCount++;
             }
             else {
-                const deduction = expected.critical ? -20 : -8;
+                const deduction = effectiveCritical ? -20 : -8;
                 bindingScore += deduction;
                 findings.push({
                     criterion: "binding_completeness",
-                    severity: expected.critical ? "critical" : "warning",
-                    message: `Service.${expected.fieldName} not bound (expected ${expected.targetType})`,
+                    severity: effectiveCritical ? "critical" : "warning",
+                    message: `Service.${expected.fieldName} not bound (expected ${expected.targetType})${expected.fieldName === "arbitrations" ? (compensationBalanceForBind > 0 ? " — required by contract when compensation_fund > 0" : " — optional when compensation_fund is 0") : ""}`,
                     deduction,
                 });
             }
@@ -681,19 +1065,19 @@ function evaluateCompleteness(input) {
     let workflowScore = 80;
     const machines = byType.get("Machine") ?? [];
     if (machines.length === 0) {
-        workflowScore -= 30;
+        workflowScore -= 20;
         findings.push({
             criterion: "workflow_rationality",
-            severity: "warning",
-            message: "No Machine object — no workflow defined",
-            deduction: -30,
+            severity: "info",
+            message: "No Machine object — bind one before publishing (deploy-time requirement)",
+            deduction: -20,
         });
     }
     else {
         for (const m of machines) {
             const data = parseCacheData(objectCache.get(m.objectAddress));
             if (data) {
-                const nodeCount = countArrayField(data, "nodes") || countArrayField(data, "node_count");
+                const nodeCount = getNumberField(data, "node_count") || countArrayField(data, "nodes");
                 if (nodeCount > 0) {
                     strengths.push(`Machine has ${nodeCount} node(s)`);
                 }
@@ -709,7 +1093,16 @@ function evaluateCompleteness(input) {
             }
         }
     }
-    const objectAddresses = new Set(objects.map(o => o.objectAddress));
+    const objectAddresses = new Set();
+    for (const o of objects) {
+        if (o.objectAddress)
+            objectAddresses.add(o.objectAddress);
+        if (o.objectName) {
+            objectAddresses.add(o.objectName);
+            const shortType = shortTypeName(o.objectType).toLowerCase();
+            objectAddresses.add(`${shortType}:${o.objectName}`);
+        }
+    }
     let danglingCount = 0;
     for (const e of edges) {
         if (e.edgeSource === "potential")
@@ -735,10 +1128,26 @@ function evaluateCompleteness(input) {
             if (published) {
                 strengths.push("Service already published — deployment complete");
                 readinessScore = 100;
+                const machineAddr = data.machine;
+                if (typeof machineAddr === "string" && machineAddr.startsWith("0x")) {
+                    const machineData = parseCacheData(objectCache.get(machineAddr));
+                    if (machineData && machineData.bPublished === false) {
+                        readinessScore -= 10;
+                        findings.push({
+                            criterion: "deployment_readiness",
+                            severity: "info",
+                            message: `Bound Machine ${machineAddr.slice(0, 8)} is not published — order_progress will fail (machine.move E_NOT_PUBLISHED)`,
+                            deduction: -10,
+                        });
+                    }
+                }
             }
             else {
                 const hasMachine = bindingIndex.get(`${services[0].objectAddress}#machine`)?.size;
                 const hasPermission = bindingIndex.get(`${services[0].objectAddress}#permission`)?.size;
+                const hasOrderAllocators = bindingIndex.get(`${services[0].objectAddress}#order_allocators`)?.size;
+                const compensationBalanceForReady = getBalanceValue(data, "compensation_fund");
+                const hasArbitrations = bindingIndex.get(`${services[0].objectAddress}#arbitrations`)?.size;
                 if (!hasMachine) {
                     readinessScore -= 30;
                     findings.push({
@@ -757,8 +1166,31 @@ function evaluateCompleteness(input) {
                         deduction: -30,
                     });
                 }
-                if (hasMachine && hasPermission) {
-                    strengths.push("Service ready to publish (Machine + Permission bound)");
+                if (!hasOrderAllocators) {
+                    readinessScore -= 30;
+                    findings.push({
+                        criterion: "deployment_readiness",
+                        severity: "critical",
+                        message: "Service has no order_allocators — cannot publish (service.move:493 E_NO_ALLOCATOR)",
+                        deduction: -30,
+                    });
+                }
+                if (compensationBalanceForReady > 0 && !hasArbitrations) {
+                    readinessScore -= 25;
+                    findings.push({
+                        criterion: "deployment_readiness",
+                        severity: "critical",
+                        message: `Service has compensation_fund (${compensationBalanceForReady}) but no arbitrations — cannot publish (service.move:495 E_ARBITRATION_NOT_SET_WITH_COMPENSATION_FUND)`,
+                        deduction: -25,
+                    });
+                }
+                if (hasMachine && hasPermission && hasOrderAllocators) {
+                    if (compensationBalanceForReady > 0 && hasArbitrations) {
+                        strengths.push("Service ready to publish (Machine + Permission + order_allocators + arbitrations bound)");
+                    }
+                    else if (compensationBalanceForReady === 0) {
+                        strengths.push("Service ready to publish (Machine + Permission + order_allocators bound; arbitrations optional when compensation_fund is 0)");
+                    }
                 }
             }
         }
@@ -781,6 +1213,9 @@ function evaluateCompleteness(input) {
         : overall >= 80
             ? `Complete project (score ${overall}/100). Ready for deployment.`
             : `Partially complete (score ${overall}/100). ${findings.length} gap(s) to address.`;
+    const industryPattern = evaluateIndustryPattern(project, objects, objectCache, edges);
+    strengths.push(...industryPattern.strengths);
+    findings.push(...industryPattern.findings);
     return {
         evaluationType: "completeness",
         score: overall,
@@ -792,7 +1227,7 @@ function evaluateCompleteness(input) {
         evaluatedAt: Date.now(),
     };
 }
-function evaluateWorthBuyingStub(input, llmPrompt) {
+function evaluateWorthBuyingStub(_input, llmPrompt) {
     return {
         evaluationType: "worth_buying",
         score: 0,
@@ -805,7 +1240,7 @@ function evaluateWorthBuyingStub(input, llmPrompt) {
         evaluatedAt: Date.now(),
     };
 }
-function evaluateValueStub(input, llmPrompt) {
+function evaluateValueStub(_input, llmPrompt) {
     return {
         evaluationType: "value",
         score: 0,
@@ -819,21 +1254,78 @@ function evaluateValueStub(input, llmPrompt) {
     };
 }
 export function runEvaluation(input, evaluationType, llmPrompt) {
+    const filtered = filterTemplateObjects(input);
     switch (evaluationType) {
         case "risk":
-            return evaluateRisk(input);
+            return evaluateRisk(filtered);
         case "trust":
-            return evaluateTrust(input);
+            return evaluateTrust(filtered);
         case "completeness":
-            return evaluateCompleteness(input);
+            return evaluateCompleteness(filtered);
         case "worth_buying":
-            return evaluateWorthBuyingStub(input, llmPrompt);
+            return evaluateWorthBuyingStub(filtered, llmPrompt);
         case "value":
-            return evaluateValueStub(input, llmPrompt);
+            return evaluateValueStub(filtered, llmPrompt);
         default:
             throw new Error(`Unknown evaluation type: ${evaluationType}`);
     }
 }
+function filterTemplateObjects(input) {
+    const isDraftAddr = (addr) => {
+        if (!addr)
+            return true;
+        return addr.startsWith("draft:");
+    };
+    const isDraftObject = (o) => {
+        if (isDraftAddr(o.objectAddress))
+            return true;
+        const meta = o.metadata;
+        return !!(meta && meta.status === "draft");
+    };
+    const draftObjects = [];
+    const realObjects = [];
+    for (const o of input.objects) {
+        if (isDraftObject(o)) {
+            draftObjects.push(o);
+        }
+        else {
+            realObjects.push(o);
+        }
+    }
+    const realIds = new Set();
+    for (const o of realObjects) {
+        if (o.objectAddress)
+            realIds.add(o.objectAddress);
+        if (o.objectName) {
+            realIds.add(o.objectName);
+            const shortType = shortTypeName(o.objectType).toLowerCase();
+            realIds.add(`${shortType}:${o.objectName}`);
+        }
+    }
+    const draftIds = new Set();
+    for (const o of draftObjects) {
+        if (o.objectAddress)
+            draftIds.add(o.objectAddress);
+        if (o.objectName) {
+            draftIds.add(o.objectName);
+            const shortType = shortTypeName(o.objectType).toLowerCase();
+            draftIds.add(`${shortType}:${o.objectName}`);
+        }
+    }
+    const realEdges = input.edges.filter((e) => {
+        const meta = e.metadata;
+        if (meta && meta.blueprint === true)
+            return false;
+        const sourceIsDraft = isDraftAddr(e.sourceObject) || draftIds.has(e.sourceObject);
+        const targetIsDraft = isDraftAddr(e.targetObject) || draftIds.has(e.targetObject);
+        return !sourceIsDraft && !targetIsDraft;
+    });
+    return {
+        ...input,
+        objects: realObjects,
+        edges: realEdges,
+    };
+}
 export function compareProjects(entries, evaluationType) {
     const ranking = [...entries].sort((a, b) => {
         if (a.score === null && b.score === null)