@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/project/evaluation.js

@@ -1,9 +1,10 @@
+import { IndustryModeRegistry } from "../extensions/registry.js";
+import { collectPermissionIndexes, checkPermissionAuthorization, } from "../schema/utils/permission-machine-check.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 +12,55 @@ 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, hasAllocationEscrow = false) {
+    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 (hasAllocationEscrow && compensationFundBalance === 0) {
+        result = result.map(item => {
+            if (item.id === "R6") {
+                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,7 +69,6 @@ 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)));
@@ -44,7 +78,11 @@ function shortTypeName(objectType) {
         return "unknown";
     const base = objectType.replace(/<.*>/, "").trim();
     const segments = base.split("::");
-    return segments[segments.length - 1] || "unknown";
+    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)
@@ -65,7 +103,125 @@ function countArrayField(data, field) {
         return v.length;
     return 0;
 }
-function detectCircularRefs(edges) {
+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 extractMachineNodesFromCache(data) {
+    if (!data)
+        return [];
+    const nodesArr = data["nodes"];
+    if (Array.isArray(nodesArr)) {
+        return nodesArr;
+    }
+    const config = data["config"];
+    if (config && Array.isArray(config["nodes"])) {
+        return config["nodes"];
+    }
+    const nodesObj = data["nodes"];
+    if (nodesObj && typeof nodesObj === "object") {
+        const fieldsObj = nodesObj["fields"];
+        if (fieldsObj && Array.isArray(fieldsObj["contents"])) {
+            return fieldsObj["contents"];
+        }
+    }
+    return [];
+}
+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, objectTypeMap) {
     const adj = new Map();
     for (const e of edges) {
         if (e.edgeSource === "potential")
@@ -78,30 +234,79 @@ 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);
                 const cycle = path.slice(cycleStart).concat(neighbor);
-                cycles.push(cycle.join("→"));
+                if (!isWoWokNormalFundCycle(cycle, objectTypeMap)) {
+                    cycles.push(cycle.join("→"));
+                }
             }
         }
-        path.pop();
-        recursionStack.delete(node);
-    };
-    for (const node of adj.keys()) {
-        if (!visited.has(node))
-            dfs(node);
     }
     return cycles;
 }
+function isWoWokNormalFundCycle(cycle, objectTypeMap) {
+    if (!objectTypeMap || cycle.length < 3)
+        return false;
+    const typesInCycle = new Set();
+    for (const addr of cycle) {
+        const type = objectTypeMap.get(addr);
+        if (type) {
+            typesInCycle.add(type);
+        }
+        else {
+            return false;
+        }
+    }
+    if (typesInCycle.size === 2 &&
+        typesInCycle.has("Order") &&
+        typesInCycle.has("Allocation")) {
+        return true;
+    }
+    if (typesInCycle.size === 3 &&
+        typesInCycle.has("Order") &&
+        typesInCycle.has("Allocation") &&
+        typesInCycle.has("Payment")) {
+        return true;
+    }
+    const workflowTypes = ["Service", "Machine", "Progress", "Order"];
+    const isWorkflowCycle = Array.from(typesInCycle).every(t => workflowTypes.includes(t));
+    if (isWorkflowCycle && typesInCycle.size >= 2) {
+        return true;
+    }
+    return false;
+}
 function adjustWeightsForPerspective(criterionScores, perspective) {
     if (perspective === "consumer") {
         return criterionScores.map(c => {
@@ -145,8 +350,186 @@ 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 = getMachineNodeCount(cached);
+            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,
+        });
+    }
+    if (industryName === "freelance") {
+        const machines = byType.get("Machine") ?? [];
+        for (const m of machines) {
+            const mData = parseCacheData(objectCache.get(m.objectAddress));
+            if (!mData)
+                continue;
+            const nodeCount = getMachineNodeCount(mData);
+            if (nodeCount > 0) {
+                result.findings.push({
+                    criterion: "industry_pattern",
+                    severity: "info",
+                    message: `ISSUE-P1-4: freelance project has a Machine with ${nodeCount} node(s). ` +
+                        `If the workflow includes a "delivered" state, 48h auto-accept requires ` +
+                        `an off-chain keeper (WoWok Guard does not support time-based triggers). ` +
+                        `Keeper should poll Progress objects in "delivered" state and call ` +
+                        `adminUnhold (permission 224) after 48h timeout.`,
+                    deduction: 0,
+                });
+                break;
+            }
+        }
+    }
+    return result;
+}
 function evaluateRisk(input) {
     const findings = [];
     const strengths = [];
@@ -162,19 +545,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,
                 });
             }
@@ -195,27 +583,97 @@ 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 allocations = byType.get("Allocation") ?? [];
+    const serviceData = serviceObj ? parseCacheData(objectCache.get(serviceObj.objectAddress)) : null;
+    const compensationBalance = serviceObj ? getBalanceValue(serviceData, "compensation_fund") : 0;
+    const orderAllocatorsBinding = serviceObj
+        ? bindingIndex.get(`${serviceObj.objectAddress}#order_allocators`)?.size ?? 0
+        : 0;
+    const hasAllocationEscrow = allocations.length > 0 && orderAllocatorsBinding > 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 (hasAllocationEscrow) {
+            fundScore -= 5;
+            strengths.push("Allocation escrow mode active — funds locked in contract, released by Guard verification");
+            findings.push({
+                criterion: "fund_safety",
+                severity: "info",
+                message: `Using Allocation escrow (${allocations.length} Allocation object(s) + order_allocators bound) — fund safety via Guard verification, no Treasury/compensation_fund needed`,
+                deduction: -5,
+            });
+        }
+        else 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) {
+                let coverageRatio = 5;
+                if (project.industry && project.industry !== "general") {
+                    try {
+                        const mode = IndustryModeRegistry.Instance().getMode(project.industry);
+                        if (mode?.risk_constraints?.compensation_fund_coverage_ratio) {
+                            coverageRatio = mode.risk_constraints.compensation_fund_coverage_ratio;
+                        }
+                    }
+                    catch { }
+                }
+                const requiredThreshold = coverageRatio * maxSalePrice;
+                if (compensationBalance < requiredThreshold) {
+                    fundScore -= 10;
+                    findings.push({
+                        criterion: "fund_safety",
+                        severity: "warning",
+                        message: `Service.compensation_fund balance (${compensationBalance}) is less than ${coverageRatio}× 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. (industry: ${project.industry ?? "general"}, ratio: ${coverageRatio}×)`,
+                        deduction: -10,
+                    });
+                }
+                else {
+                    findings.push({
+                        criterion: "fund_safety",
+                        severity: "info",
+                        message: `Service.compensation_fund balance (${compensationBalance}) covers ${coverageRatio}× the max order amount (${maxSalePrice}). Fund is sufficient for refund protection. (industry: ${project.industry ?? "general"}, ratio: ${coverageRatio}×)`,
+                        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,
             });
         }
     }
@@ -274,18 +732,181 @@ 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,
+            });
+        }
+    }
+    const machines = byType.get("Machine") ?? [];
+    for (const machineObj of machines) {
+        const meta = machineObj.metadata;
+        const config = meta?.config;
+        if (config?.entry_node_forward_hint) {
+            const hint = config.entry_node_forward_hint;
+            const exampleFwd = hint.example_forward;
+            if (exampleFwd?.namedOperator === "") {
+                strengths.push("Machine entry forward uses namedOperator='' (OrderHolder) — " +
+                    "correct for customer-operable nodes. namedOperator='' represents " +
+                    "the order holder, distinct from merchant's permission index.");
+            }
+        }
+        const guardObjects = config?.guard_objects;
+        if (guardObjects && guardObjects.length > 0) {
+            strengths.push(`Machine has ${guardObjects.length} guard object reference(s) — ` +
+                `forward-level permission validation configured`);
+        }
+        const cached = parseCacheData(objectCache.get(machineObj.objectAddress));
+        const nodeCount = getMachineNodeCount(cached);
+        if (nodeCount > 0 && !config) {
+            findings.push({
+                criterion: "governance_risk",
+                severity: "info",
+                message: `Machine has ${nodeCount} node(s). Verify each forward has at least one of ` +
+                    `namedOperator or permissionIndex. Key: namedOperator='' means OrderHolder ` +
+                    `(customer), NOT 'anyone'. Use non-empty namedOperator for specific roles, ` +
+                    `or permissionIndex for permission-based access. Both set = OR semantic ` +
+                    `(either can execute).`,
+                deduction: 0,
+            });
+        }
+    }
+    const machinesForPermCheck = byType.get("Machine") ?? [];
+    const permissionsForCheck = byType.get("Permission") ?? [];
+    const permDataMap = new Map();
+    for (const permObj of permissionsForCheck) {
+        const cached = parseCacheData(objectCache.get(permObj.objectAddress));
+        if (cached) {
+            permDataMap.set(permObj.objectAddress, {
+                address: permObj.objectAddress,
+                entity_count: typeof cached.entity_count === "number" ? cached.entity_count : undefined,
+                perm_remark: Array.isArray(cached.perm_remark) ? cached.perm_remark : undefined,
+                owner: typeof cached.owner === "string" ? cached.owner : (typeof cached.builder === "string" ? cached.builder : undefined),
+                admin: Array.isArray(cached.admin) ? cached.admin : undefined,
+            });
+        }
+    }
+    for (const machineObj of machinesForPermCheck) {
+        const machinePermKey = `${machineObj.objectAddress}#permission`;
+        const machinePermBindings = bindingIndex.get(machinePermKey);
+        if (!machinePermBindings || machinePermBindings.size === 0)
+            continue;
+        let permAddress = null;
+        for (const addr of machinePermBindings) {
+            permAddress = addr;
+            break;
+        }
+        if (!permAddress)
+            continue;
+        const permData = permDataMap.get(permAddress);
+        if (!permData)
+            continue;
+        const machineCached = parseCacheData(objectCache.get(machineObj.objectAddress));
+        if (!machineCached)
+            continue;
+        const machineNodes = extractMachineNodesFromCache(machineCached);
+        if (machineNodes.length === 0)
+            continue;
+        const collection = collectPermissionIndexes(machineNodes);
+        if (collection.requiredIndexes.length === 0)
+            continue;
+        const report = checkPermissionAuthorization(collection.requiredIndexes, permData);
+        if (!report.allAuthorized) {
+            governanceScore -= 25;
+            findings.push({
+                criterion: "governance_risk",
+                severity: "critical",
+                message: `Machine ${machineObj.objectAddress.slice(0, 8)} has forwards referencing ` +
+                    `un-authorized permission indexes: [${report.missingIndexes.join(", ")}]. ` +
+                    `These forwards can NEVER be executed — Progress will be permanently stuck. ` +
+                    `Grant entities for these indexes via permission.op="add perm by index" ` +
+                    `before publishing the Machine.`,
+                deduction: -25,
             });
         }
+        else {
+            strengths.push(`Machine ${machineObj.objectAddress.slice(0, 8)}: all ${collection.requiredIndexes.length} ` +
+                `permission index(es) are authorized`);
+        }
+    }
+    if (serviceObj && arbitrations.length > 0) {
+        const svcPermKey = `${serviceObj.objectAddress}#permission`;
+        const svcPermBindings = bindingIndex.get(svcPermKey);
+        const svcPermAddress = svcPermBindings && svcPermBindings.size > 0
+            ? Array.from(svcPermBindings)[0]
+            : null;
+        const svcPermData = svcPermAddress ? permDataMap.get(svcPermAddress) : null;
+        for (const arbObj of arbitrations) {
+            const arbPermKey = `${arbObj.objectAddress}#permission`;
+            const arbPermBindings = bindingIndex.get(arbPermKey);
+            const arbPermAddress = arbPermBindings && arbPermBindings.size > 0
+                ? Array.from(arbPermBindings)[0]
+                : null;
+            if (!svcPermAddress || !arbPermAddress)
+                continue;
+            if (svcPermAddress === arbPermAddress) {
+                governanceScore -= 30;
+                findings.push({
+                    criterion: "governance_risk",
+                    severity: "critical",
+                    message: `Arbitration ${arbObj.objectAddress.slice(0, 8)} and Service share the SAME ` +
+                        `Permission object (${svcPermAddress.slice(0, 8)}). This breaks dispute ` +
+                        `fairness — the merchant fully controls arbitration operations. ` +
+                        `Use a separate Permission object for Arbitration to ensure independent ` +
+                        `dispute resolution. (per arbitration.move: the permission field controls ` +
+                        `who can vote, confirm, and execute arbitration rulings)`,
+                    deduction: -30,
+                });
+                continue;
+            }
+            const arbPermData = permDataMap.get(arbPermAddress);
+            if (svcPermData && arbPermData) {
+                const svcOwner = svcPermData.owner?.toLowerCase();
+                const arbOwner = arbPermData.owner?.toLowerCase();
+                const svcAdmins = new Set((svcPermData.admin ?? []).map(a => a.toLowerCase()));
+                const arbAdmins = new Set((arbPermData.admin ?? []).map(a => a.toLowerCase()));
+                const ownerOverlap = svcOwner && arbOwner && svcOwner === arbOwner;
+                const adminOverlap = [...svcAdmins].some(a => arbAdmins.has(a));
+                if (ownerOverlap || adminOverlap) {
+                    const overlapType = ownerOverlap && adminOverlap
+                        ? "owner AND admin overlap"
+                        : ownerOverlap ? "same owner" : "admin overlap";
+                    governanceScore -= 20;
+                    findings.push({
+                        criterion: "governance_risk",
+                        severity: "warning",
+                        message: `Arbitration ${arbObj.objectAddress.slice(0, 8)} and Service have ` +
+                            `overlapping Permission control (${overlapType}). Even with separate ` +
+                            `Permission objects, shared control undermines dispute independence. ` +
+                            `For mainnet deployment, use a completely independent third-party ` +
+                            `Permission (different owner and admin list) for Arbitration. ` +
+                            `(testnet may tolerate this, but mainnet users should treat this as ` +
+                            `a critical trust factor)`,
+                        deduction: -20,
+                    });
+                }
+                else {
+                    strengths.push(`Arbitration ${arbObj.objectAddress.slice(0, 8)} has independent ` +
+                        `Permission (separate owner/admin) — trustworthy dispute resolution`);
+                }
+            }
+        }
     }
     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")
@@ -303,7 +924,13 @@ function evaluateRisk(input) {
             deduction,
         });
     }
-    const cycles = detectCircularRefs(edges);
+    const objectTypeMap = new Map();
+    for (const o of objects) {
+        if (o.objectAddress) {
+            objectTypeMap.set(o.objectAddress, shortTypeName(o.objectType));
+        }
+    }
+    const cycles = detectCircularRefs(edges, objectTypeMap);
     if (cycles.length > 0) {
         coherenceScore -= 15;
         findings.push({
@@ -423,15 +1050,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);
@@ -491,14 +1113,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;
@@ -524,20 +1148,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,
                 });
             }
         }
@@ -592,7 +1228,17 @@ function evaluateCompleteness(input) {
     }
     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 allocationsForItems = byType.get("Allocation") ?? [];
+    const orderAllocatorsBindingForItems = svcObjForRequiredItems
+        ? bindingIndex.get(`${svcObjForRequiredItems.objectAddress}#order_allocators`)?.size ?? 0
+        : 0;
+    const hasAllocationEscrowForItems = allocationsForItems.length > 0 && orderAllocatorsBindingForItems > 0;
+    const requiredItems = resolveRequiredItems(project.industry ?? undefined, compensationBalanceForItems, hasAllocationEscrowForItems);
     const requiredCount = requiredItems.filter(r => r.required).length;
     const optionalItems = requiredItems.filter(r => !r.required);
     let requiredMet = 0;
@@ -650,23 +1296,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,
                 });
             }
@@ -688,19 +1339,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 = getMachineNodeCount(data);
                 if (nodeCount > 0) {
                     strengths.push(`Machine has ${nodeCount} node(s)`);
                 }
@@ -716,7 +1367,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")
@@ -742,10 +1402,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({
@@ -764,8 +1440,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)");
+                    }
                 }
             }
         }
@@ -788,6 +1487,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,
@@ -800,19 +1502,45 @@ function evaluateCompleteness(input) {
     };
 }
 function evaluateWorthBuyingStub(input, llmPrompt) {
+    const riskResult = evaluateRisk(input);
+    const trustResult = evaluateTrust(input);
+    const completenessResult = evaluateCompleteness(input);
+    const summaryLines = [
+        "=== RULE-BASED EVALUATION SUMMARY (F-08 enriched context) ===",
+        "",
+        `Risk: ${riskResult.score}/100 — ${riskResult.summary}`,
+        ...riskResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        `Trust: ${trustResult.score}/100 — ${trustResult.summary}`,
+        ...trustResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        `Completeness: ${completenessResult.score}/100 — ${completenessResult.summary}`,
+        ...completenessResult.findings.slice(0, 3).map(f => `  - [${f.severity}] ${f.message}`),
+        "",
+        "=== END RULE-BASED SUMMARY ===",
+        "",
+    ];
+    const enrichment = summaryLines.join("\n");
+    const enrichedPrompt = llmPrompt
+        ? `${llmPrompt}\n\n${enrichment}`
+        : `${enrichment}\nInstruction: Based on the rule-based summary above, ` +
+            "evaluate whether this project is worth buying. Return a 0-100 score " +
+            "and a brief rationale. Focus on buyer risk vs. value proposition.";
     return {
         evaluationType: "worth_buying",
         score: 0,
-        summary: "Requires LLM evaluation — semantic prompt assembled. Call save_evaluation with the LLM result.",
+        summary: "Requires LLM evaluation — semantic prompt assembled with rule-based " +
+            "context (risk/trust/completeness summary). Call save_evaluation with " +
+            "the LLM result.",
         criterionScores: [],
         findings: [],
         strengths: [],
         needsLlm: true,
-        llmPrompt,
+        llmPrompt: enrichedPrompt,
         evaluatedAt: Date.now(),
     };
 }
-function evaluateValueStub(input, llmPrompt) {
+function evaluateValueStub(_input, llmPrompt) {
     return {
         evaluationType: "value",
         score: 0,
@@ -826,21 +1554,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)