@wowok/agent-mcp 2.5.4 → 2.6.0

package/dist/project/evaluation.js

@@ -0,0 +1,860 @@
+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: "Arbitration", fieldName: "arbitrations", critical: false },
+    { sourceType: "Machine", targetType: "Permission", fieldName: "permission", critical: true },
+];
+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: "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" },
+];
+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: "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 },
+    { id: "E8", check: "Contact is available (merchant reachable)", severity: "info", deduction: -5 },
+    { id: "E9", check: "Repository has published data (transparency)", severity: "info", deduction: -5 },
+    { 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("::");
+    return segments[segments.length - 1] || "unknown";
+}
+function parseCacheData(cached) {
+    if (!cached)
+        return null;
+    try {
+        return JSON.parse(cached.data);
+    }
+    catch {
+        return null;
+    }
+}
+function isAddress(v) {
+    return typeof v === "string" && v.startsWith("0x") && v.length >= 10;
+}
+function countArrayField(data, field) {
+    const v = data[field];
+    if (Array.isArray(v))
+        return v.length;
+    return 0;
+}
+function detectCircularRefs(edges) {
+    const adj = new Map();
+    for (const e of edges) {
+        if (e.edgeSource === "potential")
+            continue;
+        if (!adj.has(e.sourceObject))
+            adj.set(e.sourceObject, []);
+        adj.get(e.sourceObject).push(e.targetObject);
+    }
+    const cycles = [];
+    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) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+            else if (recursionStack.has(neighbor)) {
+                const cycleStart = path.indexOf(neighbor);
+                const cycle = path.slice(cycleStart).concat(neighbor);
+                cycles.push(cycle.join("→"));
+            }
+        }
+        path.pop();
+        recursionStack.delete(node);
+    };
+    for (const node of adj.keys()) {
+        if (!visited.has(node))
+            dfs(node);
+    }
+    return cycles;
+}
+function adjustWeightsForPerspective(criterionScores, perspective) {
+    if (perspective === "consumer") {
+        return criterionScores.map(c => {
+            if (c.name === "reputation" || c.name === "arbitration_coverage" || c.name === "consumer_diligence") {
+                return { ...c, weight: c.weight * 1.4 };
+            }
+            if (c.name === "structural_risk" || c.name === "deployment_readiness") {
+                return { ...c, weight: c.weight * 0.7 };
+            }
+            return c;
+        });
+    }
+    if (perspective === "producer") {
+        return criterionScores.map(c => {
+            if (c.name === "structural_risk" || c.name === "deployment_readiness" || c.name === "binding_completeness") {
+                return { ...c, weight: c.weight * 1.3 };
+            }
+            if (c.name === "consumer_diligence" || c.name === "transparency") {
+                return { ...c, weight: c.weight * 0.7 };
+            }
+            return c;
+        });
+    }
+    return criterionScores;
+}
+function normalizeWeights(criterionScores) {
+    const total = criterionScores.reduce((sum, c) => sum + c.weight, 0);
+    if (total === 0)
+        return criterionScores;
+    return criterionScores.map(c => ({ ...c, weight: c.weight / total }));
+}
+function buildBindingIndex(edges) {
+    const idx = new Map();
+    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.set(key, new Set());
+        idx.get(key).add(e.targetObject);
+    }
+    return idx;
+}
+function evaluateRisk(input) {
+    const findings = [];
+    const strengths = [];
+    const { objects, edges, objectCache, project } = input;
+    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 services = byType.get("Service") ?? [];
+    const bindingIndex = buildBindingIndex(edges);
+    let structuralScore = 100;
+    const serviceObj = services[0];
+    if (serviceObj) {
+        for (const expected of CRITICAL_BINDINGS) {
+            if (expected.sourceType !== "Service")
+                continue;
+            const key = `${serviceObj.objectAddress}#${expected.fieldName}`;
+            const bindings = bindingIndex.get(key);
+            if (!bindings || bindings.size === 0) {
+                const deduction = expected.critical ? -25 : -10;
+                structuralScore += deduction;
+                findings.push({
+                    criterion: "structural_risk",
+                    severity: expected.critical ? "critical" : "warning",
+                    message: `Service missing ${expected.fieldName} binding (expected ${expected.targetType})`,
+                    deduction,
+                });
+            }
+            else {
+                strengths.push(`Service has ${expected.fieldName} binding`);
+            }
+        }
+    }
+    else {
+        structuralScore = 30;
+        findings.push({
+            criterion: "structural_risk",
+            severity: "critical",
+            message: "No Service object in project — project has no core",
+            deduction: -70,
+        });
+    }
+    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`);
+    }
+    if (serviceObj) {
+        const cfKey = `${serviceObj.objectAddress}#compensation_fund`;
+        if (!bindingIndex.get(cfKey)?.size) {
+            fundScore -= 20;
+            findings.push({
+                criterion: "fund_safety",
+                severity: "warning",
+                message: "Service compensation_fund not bound — buyer refunds unprotected",
+                deduction: -20,
+            });
+        }
+    }
+    fundScore = clampScore(fundScore);
+    let operationalScore = 100;
+    if (serviceObj) {
+        const data = parseCacheData(objectCache.get(serviceObj.objectAddress));
+        if (data) {
+            const paused = data.bPaused;
+            const published = data.bPublished;
+            if (published && paused) {
+                operationalScore -= 25;
+                findings.push({
+                    criterion: "operational_risk",
+                    severity: "warning",
+                    message: "Service is published but PAUSED — operations halted",
+                    deduction: -25,
+                });
+            }
+            if (!published) {
+                operationalScore -= 15;
+                findings.push({
+                    criterion: "operational_risk",
+                    severity: "info",
+                    message: "Service not yet published — project not live",
+                    deduction: -15,
+                });
+            }
+        }
+    }
+    const arbitrations = byType.get("Arbitration") ?? [];
+    if (arbitrations.length === 0) {
+        operationalScore -= 20;
+        findings.push({
+            criterion: "operational_risk",
+            severity: "warning",
+            message: "No Arbitration object — disputes cannot be resolved",
+            deduction: -20,
+        });
+    }
+    else {
+        strengths.push(`${arbitrations.length} Arbitration object(s) configured`);
+    }
+    operationalScore = clampScore(operationalScore);
+    let governanceScore = 100;
+    const permissions = byType.get("Permission") ?? [];
+    if (permissions.length === 0) {
+        governanceScore -= 40;
+        findings.push({
+            criterion: "governance_risk",
+            severity: "critical",
+            message: "No Permission object — project is ungoverned",
+            deduction: -40,
+        });
+    }
+    if (serviceObj) {
+        const data = parseCacheData(objectCache.get(serviceObj.objectAddress));
+        if (data && !isAddress(data.um)) {
+            governanceScore -= 15;
+            findings.push({
+                criterion: "governance_risk",
+                severity: "warning",
+                message: "Service has no UM (manager) — cannot be managed on-chain",
+                deduction: -15,
+            });
+        }
+    }
+    governanceScore = clampScore(governanceScore);
+    let coherenceScore = 100;
+    const objectAddresses = new Set(objects.map(o => o.objectAddress));
+    let danglingCount = 0;
+    for (const e of edges) {
+        if (e.edgeSource === "potential")
+            continue;
+        if (!objectAddresses.has(e.targetObject))
+            danglingCount++;
+    }
+    if (danglingCount > 0) {
+        const deduction = -Math.min(20, danglingCount * 3);
+        coherenceScore += deduction;
+        findings.push({
+            criterion: "graph_coherence",
+            severity: danglingCount >= 3 ? "warning" : "info",
+            message: `${danglingCount} edge(s) point to objects outside the project — dangling references`,
+            deduction,
+        });
+    }
+    const cycles = detectCircularRefs(edges);
+    if (cycles.length > 0) {
+        coherenceScore -= 15;
+        findings.push({
+            criterion: "graph_coherence",
+            severity: "warning",
+            message: `${cycles.length} circular reference(s) detected: ${cycles.slice(0, 2).join("; ")}${cycles.length > 2 ? "..." : ""}`,
+            deduction: -15,
+        });
+    }
+    if (danglingCount === 0 && cycles.length === 0) {
+        strengths.push("Graph is coherent — no dangling refs or cycles");
+    }
+    coherenceScore = clampScore(coherenceScore);
+    let criterionScores = [
+        { name: "structural_risk", score: structuralScore, weight: 0.25, rationale: `${CRITICAL_BINDINGS.filter(b => b.sourceType === "Service").length} expected Service bindings checked` },
+        { name: "fund_safety", score: fundScore, weight: 0.2, rationale: `Treasury + compensation_fund coverage` },
+        { name: "operational_risk", score: operationalScore, weight: 0.2, rationale: `Service state + arbitration coverage` },
+        { name: "governance_risk", score: governanceScore, weight: 0.15, rationale: `Permission + UM presence` },
+        { name: "graph_coherence", score: coherenceScore, weight: 0.2, rationale: `${danglingCount} dangling + ${cycles.length} circular refs` },
+    ];
+    criterionScores = normalizeWeights(adjustWeightsForPerspective(criterionScores, project.perspective));
+    const overall = clampScore(criterionScores.reduce((sum, c) => sum + c.score * c.weight, 0));
+    const criticalCount = findings.filter(f => f.severity === "critical").length;
+    const summary = criticalCount > 0
+        ? `HIGH RISK: ${criticalCount} critical issue(s). ${findings.length} total findings.`
+        : `Moderate risk: ${findings.length} finding(s), no critical issues.`;
+    return {
+        evaluationType: "risk",
+        score: overall,
+        summary,
+        criterionScores,
+        findings,
+        strengths,
+        needsLlm: false,
+        evaluatedAt: Date.now(),
+    };
+}
+function evaluateTrust(input) {
+    const findings = [];
+    const strengths = [];
+    const { objects, edges, objectCache, reputation, project } = input;
+    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 services = byType.get("Service") ?? [];
+    let reputationScore = 50;
+    if (reputation && reputation.size > 0 && services[0]) {
+        const rep = reputation.get(services[0].objectAddress);
+        if (rep) {
+            const total = rep.likes + rep.dislikes;
+            if (total > 0) {
+                const ratio = rep.likes / total;
+                reputationScore = clampScore(50 + (ratio - 0.5) * 100);
+                if (ratio >= 0.8) {
+                    strengths.push(`Strong reputation: ${rep.likes} likes vs ${rep.dislikes} dislikes`);
+                }
+                else if (ratio < 0.4) {
+                    findings.push({
+                        criterion: "reputation",
+                        severity: "warning",
+                        message: `Poor reputation: ${rep.dislikes} dislikes vs ${rep.likes} likes`,
+                        deduction: -20,
+                    });
+                }
+            }
+            if (rep.affiliations >= 3) {
+                strengths.push(`${rep.affiliations} affiliations — trusted by other merchants`);
+                reputationScore = clampScore(reputationScore + 10);
+            }
+        }
+    }
+    else {
+        findings.push({
+            criterion: "reputation",
+            severity: "info",
+            message: "No Registrar reputation data — unknown merchant standing",
+            deduction: -10,
+        });
+    }
+    reputationScore = clampScore(reputationScore);
+    let arbitrationScore = 100;
+    const arbitrations = byType.get("Arbitration") ?? [];
+    if (arbitrations.length === 0) {
+        arbitrationScore = 30;
+        findings.push({
+            criterion: "arbitration_coverage",
+            severity: "critical",
+            message: "No Arbitration object — buyers have no dispute resolution path",
+            deduction: -70,
+        });
+    }
+    else {
+        strengths.push(`${arbitrations.length} Arbitration object(s) — dispute resolution available`);
+    }
+    arbitrationScore = clampScore(arbitrationScore);
+    let guardScore = 60;
+    const guards = byType.get("Guard") ?? [];
+    if (guards.length === 0) {
+        guardScore -= 20;
+        findings.push({
+            criterion: "guard_quality",
+            severity: "warning",
+            message: "No Guard objects — no validation rules",
+            deduction: -20,
+        });
+    }
+    else {
+        guardScore = 80;
+        strengths.push(`${guards.length} Guard object(s) — validation rules configured`);
+    }
+    if (services[0]) {
+        const bindingIndex = buildBindingIndex(edges);
+        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");
+        }
+        else {
+            findings.push({
+                criterion: "guard_quality",
+                severity: "warning",
+                message: "Service buy_guard not bound — unvalidated purchases",
+                deduction: -15,
+            });
+        }
+    }
+    guardScore = clampScore(guardScore);
+    let transparencyScore = 60;
+    if (services[0]) {
+        const data = parseCacheData(objectCache.get(services[0].objectAddress));
+        if (data) {
+            const desc = data.description;
+            if (typeof desc === "string" && desc.length > 0) {
+                transparencyScore += 15;
+                strengths.push("Service has description");
+            }
+            else {
+                findings.push({
+                    criterion: "transparency",
+                    severity: "info",
+                    message: "Service has no description — buyers cannot evaluate offering",
+                    deduction: -10,
+                });
+            }
+        }
+    }
+    const repositories = byType.get("Repository") ?? [];
+    if (repositories.length > 0) {
+        transparencyScore = clampScore(transparencyScore + 10);
+        strengths.push(`${repositories.length} Repository object(s) — supporting data published`);
+    }
+    const contacts = byType.get("Contact") ?? [];
+    if (contacts.length > 0) {
+        transparencyScore = clampScore(transparencyScore + 10);
+        strengths.push("Contact information available");
+    }
+    else {
+        findings.push({
+            criterion: "transparency",
+            severity: "info",
+            message: "No Contact object — buyers cannot reach merchant",
+            deduction: -5,
+        });
+    }
+    transparencyScore = clampScore(transparencyScore);
+    let diligenceScore = 100;
+    const diligencePassed = [];
+    const bindingIndex2 = buildBindingIndex(edges);
+    const serviceObj2 = services[0];
+    if (serviceObj2) {
+        const svcData = parseCacheData(objectCache.get(serviceObj2.objectAddress));
+        for (const check of CONSUMER_DUE_DILIGENCE) {
+            let passed = false;
+            switch (check.id) {
+                case "E1":
+                    passed = !!(svcData?.bPublished);
+                    break;
+                case "E2":
+                    passed = !!svcData && !svcData.bPaused;
+                    break;
+                case "E3":
+                    passed = (byType.get("Machine") ?? []).some(m => {
+                        const d = parseCacheData(objectCache.get(m.objectAddress));
+                        return d && (countArrayField(d, "nodes") > 0);
+                    });
+                    break;
+                case "E4":
+                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#buy_guard`)?.size;
+                    break;
+                case "E5":
+                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#compensation_fund`)?.size;
+                    break;
+                case "E6":
+                    passed = (byType.get("Arbitration") ?? []).length > 0;
+                    break;
+                case "E7":
+                    passed = (byType.get("Permission") ?? []).length > 0;
+                    break;
+                case "E8":
+                    passed = (byType.get("Contact") ?? []).length > 0;
+                    break;
+                case "E9":
+                    passed = (byType.get("Repository") ?? []).length > 0;
+                    break;
+                case "E10":
+                    passed = !!bindingIndex2.get(`${serviceObj2.objectAddress}#rewards`)?.size;
+                    break;
+                case "E11":
+                    passed = !!(svcData && typeof svcData.description === "string" && svcData.description.length > 0);
+                    break;
+                case "E12":
+                    if (reputation && reputation.size > 0) {
+                        const rep = reputation.get(serviceObj2.objectAddress);
+                        passed = !!rep && rep.likes >= rep.dislikes;
+                    }
+                    break;
+                case "E13":
+                    passed = true;
+                    break;
+            }
+            if (passed) {
+                diligencePassed.push(check.id);
+            }
+            else {
+                diligenceScore += check.deduction;
+                findings.push({
+                    criterion: "consumer_diligence",
+                    severity: check.severity,
+                    message: `${check.id}: ${check.check} — FAILED`,
+                    deduction: check.deduction,
+                });
+            }
+        }
+        const passRate = diligencePassed.length / CONSUMER_DUE_DILIGENCE.length;
+        if (passRate >= 0.8) {
+            strengths.push(`Consumer due diligence: ${diligencePassed.length}/${CONSUMER_DUE_DILIGENCE.length} checks passed`);
+        }
+    }
+    else {
+        diligenceScore = 20;
+        findings.push({
+            criterion: "consumer_diligence",
+            severity: "critical",
+            message: "No Service object — consumer due diligence cannot be performed",
+            deduction: -80,
+        });
+    }
+    diligenceScore = clampScore(diligenceScore);
+    let criterionScores = [
+        { name: "reputation", score: reputationScore, weight: 0.25, rationale: `Registrar likes/dislikes + affiliations` },
+        { name: "arbitration_coverage", score: arbitrationScore, weight: 0.2, rationale: `Dispute resolution availability` },
+        { name: "guard_quality", score: guardScore, weight: 0.2, rationale: `Validation rules + buy_guard binding` },
+        { name: "transparency", score: transparencyScore, weight: 0.15, rationale: `Description + Repository + Contact presence` },
+        { name: "consumer_diligence", score: diligenceScore, weight: 0.2, rationale: `${diligencePassed.length}/${CONSUMER_DUE_DILIGENCE.length} E-checks passed` },
+    ];
+    criterionScores = normalizeWeights(adjustWeightsForPerspective(criterionScores, project.perspective));
+    const overall = clampScore(criterionScores.reduce((sum, c) => sum + c.score * c.weight, 0));
+    const summary = overall >= 70
+        ? `Trusted project (score ${overall}/100). ${strengths.length} strength(s).`
+        : `Limited trust signals (score ${overall}/100). ${findings.length} finding(s).`;
+    return {
+        evaluationType: "trust",
+        score: overall,
+        summary,
+        criterionScores,
+        findings,
+        strengths,
+        needsLlm: false,
+        evaluatedAt: Date.now(),
+    };
+}
+function evaluateCompleteness(input) {
+    const findings = [];
+    const strengths = [];
+    const { objects, edges, objectCache, project } = input;
+    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 services = byType.get("Service") ?? [];
+    const bindingIndex = buildBindingIndex(edges);
+    const requiredItems = MERCHANT_REQUIRED_ITEMS;
+    const requiredCount = requiredItems.filter(r => r.required).length;
+    const optionalItems = requiredItems.filter(r => !r.required);
+    let requiredMet = 0;
+    let optionalMet = 0;
+    const missingRequired = [];
+    const missingOptional = [];
+    for (const item of requiredItems) {
+        const hasObject = (byType.get(item.objectType)?.length ?? 0) > 0;
+        const hasBinding = item.fieldName
+            ? !!bindingIndex.get(`${services[0]?.objectAddress ?? ""}#${item.fieldName}`)?.size
+            : hasObject;
+        if (item.required) {
+            if (hasBinding || (!item.fieldName && hasObject)) {
+                requiredMet++;
+            }
+            else {
+                missingRequired.push(`${item.id}(${item.objectType})`);
+            }
+        }
+        else {
+            if (hasBinding || (!item.fieldName && hasObject)) {
+                optionalMet++;
+            }
+            else {
+                missingOptional.push(`${item.id}(${item.objectType})`);
+            }
+        }
+    }
+    const requiredRatio = requiredMet / requiredCount;
+    const optionalRatio = optionalItems.length > 0 ? optionalMet / optionalItems.length : 1;
+    let coverageScore = clampScore(requiredRatio * 80 + optionalRatio * 20);
+    if (missingRequired.length > 0) {
+        findings.push({
+            criterion: "object_coverage",
+            severity: missingRequired.length >= 3 ? "critical" : "warning",
+            message: `Missing required items: ${missingRequired.join(", ")} — ${missingRequired.length}/${requiredCount} required items absent`,
+            deduction: -15 * missingRequired.length,
+        });
+    }
+    else {
+        strengths.push(`All ${requiredCount} required items present (R1-R8)`);
+    }
+    if (missingOptional.length > 0 && missingOptional.length === optionalItems.length) {
+        findings.push({
+            criterion: "object_coverage",
+            severity: "info",
+            message: `No optional items configured: ${missingOptional.join(", ")} — recommended for enhanced UX`,
+            deduction: -5,
+        });
+    }
+    else if (optionalMet > 0) {
+        strengths.push(`${optionalMet}/${optionalItems.length} optional items configured (R9-R12)`);
+    }
+    coverageScore = clampScore(coverageScore);
+    let bindingScore = 100;
+    if (services[0]) {
+        const serviceAddr = services[0].objectAddress;
+        let boundCount = 0;
+        let totalCount = 0;
+        for (const expected of CRITICAL_BINDINGS) {
+            if (expected.sourceType !== "Service")
+                continue;
+            totalCount++;
+            const key = `${serviceAddr}#${expected.fieldName}`;
+            if (bindingIndex.get(key)?.size) {
+                boundCount++;
+            }
+            else {
+                const deduction = expected.critical ? -20 : -8;
+                bindingScore += deduction;
+                findings.push({
+                    criterion: "binding_completeness",
+                    severity: expected.critical ? "critical" : "warning",
+                    message: `Service.${expected.fieldName} not bound (expected ${expected.targetType})`,
+                    deduction,
+                });
+            }
+        }
+        if (boundCount === totalCount) {
+            strengths.push(`All ${totalCount} Service bindings established`);
+        }
+    }
+    else {
+        bindingScore = 0;
+        findings.push({
+            criterion: "binding_completeness",
+            severity: "critical",
+            message: "No Service object — cannot evaluate bindings",
+            deduction: -100,
+        });
+    }
+    bindingScore = clampScore(bindingScore);
+    let workflowScore = 80;
+    const machines = byType.get("Machine") ?? [];
+    if (machines.length === 0) {
+        workflowScore -= 30;
+        findings.push({
+            criterion: "workflow_rationality",
+            severity: "warning",
+            message: "No Machine object — no workflow defined",
+            deduction: -30,
+        });
+    }
+    else {
+        for (const m of machines) {
+            const data = parseCacheData(objectCache.get(m.objectAddress));
+            if (data) {
+                const nodeCount = countArrayField(data, "nodes") || countArrayField(data, "node_count");
+                if (nodeCount > 0) {
+                    strengths.push(`Machine has ${nodeCount} node(s)`);
+                }
+                else {
+                    workflowScore -= 10;
+                    findings.push({
+                        criterion: "workflow_rationality",
+                        severity: "info",
+                        message: `Machine ${m.objectAddress.slice(0, 8)} has no nodes`,
+                        deduction: -10,
+                    });
+                }
+            }
+        }
+    }
+    const objectAddresses = new Set(objects.map(o => o.objectAddress));
+    let danglingCount = 0;
+    for (const e of edges) {
+        if (e.edgeSource === "potential")
+            continue;
+        if (!objectAddresses.has(e.targetObject))
+            danglingCount++;
+    }
+    if (danglingCount > 0) {
+        workflowScore = clampScore(workflowScore - Math.min(20, danglingCount * 2));
+        findings.push({
+            criterion: "workflow_rationality",
+            severity: "info",
+            message: `${danglingCount} edge(s) point to objects not in project — dangling references`,
+            deduction: -Math.min(20, danglingCount * 2),
+        });
+    }
+    workflowScore = clampScore(workflowScore);
+    let readinessScore = 100;
+    if (services[0]) {
+        const data = parseCacheData(objectCache.get(services[0].objectAddress));
+        if (data) {
+            const published = data.bPublished;
+            if (published) {
+                strengths.push("Service already published — deployment complete");
+                readinessScore = 100;
+            }
+            else {
+                const hasMachine = bindingIndex.get(`${services[0].objectAddress}#machine`)?.size;
+                const hasPermission = bindingIndex.get(`${services[0].objectAddress}#permission`)?.size;
+                if (!hasMachine) {
+                    readinessScore -= 30;
+                    findings.push({
+                        criterion: "deployment_readiness",
+                        severity: "critical",
+                        message: "Service has no Machine — cannot publish",
+                        deduction: -30,
+                    });
+                }
+                if (!hasPermission) {
+                    readinessScore -= 30;
+                    findings.push({
+                        criterion: "deployment_readiness",
+                        severity: "critical",
+                        message: "Service has no Permission — cannot publish",
+                        deduction: -30,
+                    });
+                }
+                if (hasMachine && hasPermission) {
+                    strengths.push("Service ready to publish (Machine + Permission bound)");
+                }
+            }
+        }
+    }
+    else {
+        readinessScore = 0;
+    }
+    readinessScore = clampScore(readinessScore);
+    let criterionScores = [
+        { name: "object_coverage", score: coverageScore, weight: 0.3, rationale: `R1-R8: ${requiredMet}/${requiredCount} required, R9-R12: ${optionalMet}/${optionalItems.length} optional` },
+        { name: "binding_completeness", score: bindingScore, weight: 0.25, rationale: `Service critical bindings checked` },
+        { name: "workflow_rationality", score: workflowScore, weight: 0.2, rationale: `Machine nodes + dangling edges` },
+        { name: "deployment_readiness", score: readinessScore, weight: 0.25, rationale: `Service publishable state` },
+    ];
+    criterionScores = normalizeWeights(adjustWeightsForPerspective(criterionScores, project.perspective));
+    const overall = clampScore(criterionScores.reduce((sum, c) => sum + c.score * c.weight, 0));
+    const criticalCount = findings.filter(f => f.severity === "critical").length;
+    const summary = criticalCount > 0
+        ? `Incomplete: ${criticalCount} critical gap(s). Not ready for deployment.`
+        : overall >= 80
+            ? `Complete project (score ${overall}/100). Ready for deployment.`
+            : `Partially complete (score ${overall}/100). ${findings.length} gap(s) to address.`;
+    return {
+        evaluationType: "completeness",
+        score: overall,
+        summary,
+        criterionScores,
+        findings,
+        strengths,
+        needsLlm: false,
+        evaluatedAt: Date.now(),
+    };
+}
+function evaluateWorthBuyingStub(input, llmPrompt) {
+    return {
+        evaluationType: "worth_buying",
+        score: 0,
+        summary: "Requires LLM evaluation — semantic prompt assembled. Call save_evaluation with the LLM result.",
+        criterionScores: [],
+        findings: [],
+        strengths: [],
+        needsLlm: true,
+        llmPrompt,
+        evaluatedAt: Date.now(),
+    };
+}
+function evaluateValueStub(input, llmPrompt) {
+    return {
+        evaluationType: "value",
+        score: 0,
+        summary: "Requires LLM evaluation — semantic prompt assembled. Call save_evaluation with the LLM result.",
+        criterionScores: [],
+        findings: [],
+        strengths: [],
+        needsLlm: true,
+        llmPrompt,
+        evaluatedAt: Date.now(),
+    };
+}
+export function runEvaluation(input, evaluationType, llmPrompt) {
+    switch (evaluationType) {
+        case "risk":
+            return evaluateRisk(input);
+        case "trust":
+            return evaluateTrust(input);
+        case "completeness":
+            return evaluateCompleteness(input);
+        case "worth_buying":
+            return evaluateWorthBuyingStub(input, llmPrompt);
+        case "value":
+            return evaluateValueStub(input, llmPrompt);
+        default:
+            throw new Error(`Unknown evaluation type: ${evaluationType}`);
+    }
+}
+export function compareProjects(entries, evaluationType) {
+    const ranking = [...entries].sort((a, b) => {
+        if (a.score === null && b.score === null)
+            return 0;
+        if (a.score === null)
+            return 1;
+        if (b.score === null)
+            return -1;
+        return b.score - a.score;
+    });
+    return {
+        evaluationType,
+        entries,
+        ranking,
+        bestProjectId: ranking[0]?.score !== null ? ranking[0]?.projectId ?? null : null,
+    };
+}