@wowok/agent-mcp 2.5.5 → 2.6.1

package/dist/project/handlers.js

@@ -1,7 +1,8 @@
-import { LocalProject, LocalMark, query_objects, } from "@wowok/wowok";
+import { LocalProject, LocalMark, query_objects, query_table, } from "@wowok/wowok";
 import { GraphBuilder } from "./graph-builder.js";
 import { SemanticAssembler } from "./semantic-assembler.js";
 import { runEvaluation, compareProjects, } from "./evaluation.js";
+import { TaskTracker } from "./task-tracker.js";
 const localProject = LocalProject.Instance();
 function requireField(value, name) {
     if (value === undefined || value === null) {
@@ -21,8 +22,17 @@ async function resolveProjectId(v) {
     throw new Error("Either 'project_id' or 'project' (prefix) is required for this action");
 }
 async function resolveObjectAddress(v) {
-    if (v.object_address)
-        return v.object_address;
+    if (v.object_address) {
+        const addr = v.object_address;
+        const isHexAddress = /^0x[0-9a-fA-F]{32,64}$/.test(addr);
+        const isDraftSentinel = addr.startsWith("draft:");
+        if (!isHexAddress && !isDraftSentinel) {
+            throw new Error(`Invalid object_address format: '${addr.slice(0, 40)}${addr.length > 40 ? "..." : ""}'. ` +
+                `Expected a valid Sui address (0x + 32-64 hex chars) or 'draft:<name>' sentinel. ` +
+                `To reference an object by name, use 'object_name_add' instead of 'object_address'.`);
+        }
+        return addr;
+    }
     if (v.object_name_add) {
         const mark = await LocalMark.Instance().get(v.object_name_add);
         if (mark?.address)
@@ -41,15 +51,30 @@ export async function handleListProjects(v) {
         filter.network = v.filter_network;
     const projects = await localProject.listProjects(Object.keys(filter).length > 0 ? filter : undefined);
     const items = await Promise.all(projects.map(async (p) => {
-        const objs = await localProject.listObjects(p.id);
+        const [objs, evals] = await Promise.all([
+            localProject.listObjects(p.id),
+            localProject.listEvaluations(p.id),
+        ]);
         const types = new Set();
         for (const o of objs) {
             if (o.objectType)
                 types.add(o.objectType);
         }
+        if (p.status === "draft" && objs.length > 0) {
+            const updated = await localProject.updateProject(p.id, { status: "active" });
+            if (updated) {
+                return {
+                    ...updated,
+                    objectCount: objs.length,
+                    evaluationCount: evals.length,
+                    objectTypes: Array.from(types),
+                };
+            }
+        }
         return {
             ...p,
             objectCount: objs.length,
+            evaluationCount: evals.length,
             objectTypes: Array.from(types),
         };
     }));
@@ -78,7 +103,128 @@ export async function handleCreateProject(v) {
         network: v.project_network ?? "testnet",
     };
     const project = await localProject.createProject(create);
-    return { action: "create_project", project };
+    const industry = v.project_industry;
+    const skipTemplates = v.skip_templates === true;
+    if (industry && industry !== "general" && !skipTemplates) {
+        try {
+            const { IndustryModeRegistry } = await import("../extensions/index.js");
+            const registry = IndustryModeRegistry.Instance();
+            const context = {
+                prefix,
+                version: project.currentVersion ?? "v1",
+                network: (project.network ?? "testnet"),
+                business_intent: v.project_description ?? name,
+                industry,
+            };
+            const blueprint = registry.applyTemplate(industry, context.business_intent, context);
+            const draftObjects = [];
+            for (const obj of blueprint.objects) {
+                const projectObj = await localProject.addObject(project.id, {
+                    objectAddress: `draft:${obj.name}`,
+                    objectType: obj.object_type,
+                    objectName: obj.name,
+                    role: obj.object_type === "service" ? "core" : "dependency",
+                    metadata: {
+                        status: "draft",
+                        config: obj.config,
+                        publish_required: obj.publish_required,
+                        description: obj.description,
+                        entry_id: obj.entry_id,
+                    },
+                });
+                draftObjects.push(projectObj);
+            }
+            const graphEdges = blueprint.edges.map((e) => ({
+                projectId: project.id,
+                sourceObject: e.from,
+                targetObject: e.to,
+                edgeSource: "internal",
+                relationshipType: mapEdgeKindToRelationshipType(e.edge_kind),
+                fieldName: e.field_path,
+                depth: 0,
+                verified: false,
+                weight: 1.0,
+                metadata: {
+                    blueprint: true,
+                    required_at_publish: e.required_at_publish,
+                },
+            }));
+            await localProject.saveGraphEdges(project.id, graphEdges);
+            return {
+                action: "create_project",
+                project,
+                blueprint: {
+                    objects_count: draftObjects.length,
+                    edges_count: graphEdges.length,
+                    industry_source: blueprint.industry_source,
+                    applied_template: blueprint.applied_template,
+                    steps_count: blueprint.steps.length,
+                    scenarios_count: blueprint.scenarios?.length ?? 0,
+                    key_risk: registry.getMode(industry)?.key_risk,
+                },
+                recommended_creation_order: getRecommendedCreationOrder(industry),
+            };
+        }
+        catch (err) {
+            return {
+                action: "create_project",
+                project,
+                blueprint_warning: `Industry template application failed: ${err.message}. Project created without blueprint — use add_object to manually add objects.`,
+                recommended_creation_order: getRecommendedCreationOrder(industry),
+            };
+        }
+    }
+    if (skipTemplates) {
+        return {
+            action: "create_project",
+            project,
+            blueprint_skipped: true,
+            hint: "skip_templates=true — no industry blueprint objects were created. Use add_object to manually add objects to this project.",
+            recommended_creation_order: getRecommendedCreationOrder(industry),
+        };
+    }
+    return {
+        action: "create_project",
+        project,
+        recommended_creation_order: getRecommendedCreationOrder(industry),
+    };
+}
+function getRecommendedCreationOrder(industry) {
+    const industryNote = industry && industry !== "general"
+        ? ` (industry="${industry}" — see IndustryMode.build_notes for overrides)`
+        : "";
+    return [
+        { step: 1, object: "Permission", reason: "Base permission object, referenced by all other objects.", required: true },
+        { step: 2, object: "Treasury", reason: "Standalone object, no dependencies. Optional but recommended for fund management.", required: false },
+        { step: 3, object: "Machine", reason: `Requires Permission. publish:true locks nodes/pairs/forwards permanently.${industryNote}`, required: true },
+        { step: 4, object: "Contact", reason: "Requires Permission. Used as Service.um (user manual / contact info).", required: true },
+        { step: 5, object: "Arbitration", reason: "Requires Permission. Optional but recommended for dispute resolution.", required: false },
+        { step: 6, object: "Service (unpublished)", reason: "Requires Permission + Machine + Contact + Arbitration. Create WITHOUT publish:true first.", required: true },
+        { step: 7, object: "Guard x N", reason: "Can reference Service via LocalMark. Create all Guards (buy_guard, allocator_guard, etc.) before publishing Service.", required: true },
+        { step: 8, object: "Service update + publish", reason: "Add order_allocators referencing Guards, then publish:true. After publish, machine/order_allocators are immutable.", required: true },
+    ];
+}
+function mapEdgeKindToRelationshipType(edgeKind) {
+    switch (edgeKind) {
+        case "machine":
+        case "compensation_fund":
+        case "parent":
+            return "bind";
+        case "order_allocators":
+            return "create";
+        case "arbitrations":
+        case "rewards":
+            return "trigger";
+        case "buy_guard":
+        case "permission":
+        case "guard":
+            return "validate";
+        case "service":
+        case "progress":
+            return "consume";
+        default:
+            return "bind";
+    }
 }
 export async function handleCreateProjectFromOnchain(v) {
     const serviceAddress = requireField(v.service_address, "service_address");
@@ -97,6 +243,31 @@ export async function handleCreateProjectFromOnchain(v) {
         }
         prefix = `${prefix}_${suffix}`;
     }
+    const otherNetwork = network === "testnet" ? "mainnet" : "testnet";
+    let rootType = null;
+    try {
+        const rootQuery = await query_objects({
+            objects: [serviceAddress],
+            network,
+        });
+        const rootObj = rootQuery?.objects?.[0];
+        if (rootObj && rootObj.object) {
+            rootType = rootObj.type ?? null;
+        }
+    }
+    catch (e) {
+        throw new Error(`Failed to query ${network} for the Service object: ` +
+            `${e instanceof Error ? e.message : String(e)}. ` +
+            `Check the network connection or try the ${otherNetwork} network.`);
+    }
+    if (!rootType) {
+        throw new Error(`Service object not found on ${network}: the address ${serviceAddress} does not exist on this network. ` +
+            `Switch to the ${otherNetwork} network and try again.`);
+    }
+    if (!rootType.includes("::service::Service")) {
+        throw new Error(`Object ${serviceAddress} is not a Service (its on-chain type is "${rootType}"). ` +
+            `Only on-chain Service objects can be imported as a project root.`);
+    }
     const project = await localProject.createProject({
         prefix,
         name,
@@ -108,7 +279,7 @@ export async function handleCreateProjectFromOnchain(v) {
         network: network,
     });
     const builder = new GraphBuilder({
-        maxDepth: v.max_depth ?? 3,
+        maxDepth: v.max_depth ?? v.depth ?? 3,
         enableRegistrar: v.enable_registrar ?? true,
         enablePotential: v.enable_potential ?? false,
         projectId: project.id,
@@ -126,9 +297,10 @@ export async function handleCreateProjectFromOnchain(v) {
         });
         objects.push(obj);
     }
+    const updatedProject = await localProject.updateProject(project.id, { status: "active" });
     return {
         action: "create_project_from_onchain",
-        project,
+        project: updatedProject ?? project,
         objects,
         graphEdgeCount: graphResult.graph.edges.length,
     };
@@ -156,16 +328,126 @@ export async function handleGetProjectDetail(v) {
     const edges = await localProject.getGraph(id);
     const evaluations = await localProject.listEvaluations(id);
     const versions = await localProject.listVersions(id);
+    let effectiveProject = project;
+    if (project.status === "draft" && objects.length > 0) {
+        const updated = await localProject.updateProject(id, { status: "active" });
+        if (updated)
+            effectiveProject = updated;
+    }
+    const needsNameFix = objects.some(o => !o.objectName);
+    const needsRoleFix = objects.some(o => o.role === "reference");
+    if (needsNameFix || needsRoleFix) {
+        const allMarks = await LocalMark.Instance().list(null);
+        const addressToName = new Map();
+        for (const m of allMarks) {
+            if (m.name && m.address) {
+                addressToName.set(m.address.toLowerCase(), m.name);
+            }
+        }
+        for (const obj of objects) {
+            const updates = {};
+            if (!obj.objectName) {
+                const name = addressToName.get(obj.objectAddress.toLowerCase());
+                if (name) {
+                    updates.objectName = name;
+                    obj.objectName = name;
+                }
+            }
+            if (obj.role === "reference" && obj.objectType) {
+                const t = obj.objectType;
+                if (t.includes("service::Service")) {
+                    updates.role = "core";
+                    obj.role = "core";
+                }
+                else if (t.includes("permission::Permission") ||
+                    t.includes("machine::Machine") ||
+                    t.includes("guard::Guard") ||
+                    t.includes("reward::Reward") ||
+                    t.includes("treasury::Treasury") ||
+                    t.includes("allocation::Allocation") ||
+                    t.includes("progress::Progress") ||
+                    t.includes("arbitration::Arbitration") ||
+                    t.includes("demand::Demand") ||
+                    t.includes("order::Order") ||
+                    t.includes("repository::Repository")) {
+                    updates.role = "dependency";
+                    obj.role = "dependency";
+                }
+            }
+            if (effectiveProject.serviceAddress &&
+                obj.objectAddress === effectiveProject.serviceAddress &&
+                obj.role !== "core") {
+                updates.role = "core";
+                obj.role = "core";
+            }
+            if (Object.keys(updates).length > 0) {
+                await localProject.updateObject(obj.id, updates).catch(() => { });
+            }
+        }
+    }
+    let serviceStatus = null;
+    if (effectiveProject.serviceAddress && effectiveProject.network) {
+        try {
+            const svcQuery = await query_objects({
+                objects: [effectiveProject.serviceAddress],
+                network: effectiveProject.network,
+            });
+            const svcData = svcQuery?.objects?.[0];
+            if (svcData) {
+                const pub = svcData.bPublished ?? svcData.published ?? svcData.b_publish;
+                const pau = svcData.bPaused ?? svcData.paused ?? svcData.b_pause;
+                serviceStatus = {
+                    published: typeof pub === "boolean" ? pub : null,
+                    paused: typeof pau === "boolean" ? pau : null,
+                };
+            }
+        }
+        catch {
+        }
+    }
+    const VALID_ROLES = new Set(["core", "dependency", "reference"]);
+    const core = objects.filter(o => o.role === "core");
+    const dependency = objects.filter(o => o.role === "dependency");
+    const reference = objects.filter(o => o.role === "reference");
+    const other = objects.filter(o => !o.role || !VALID_ROLES.has(o.role));
+    if (other.length > 0) {
+        console.warn(`[handleGetProjectDetail] ${other.length} object(s) have invalid or missing role ` +
+            `(expected one of: ${Array.from(VALID_ROLES).join(", ")}). ` +
+            `They are grouped into 'other' for visibility. ` +
+            `Object names: ${other.map(o => o.objectName ?? o.objectAddress).slice(0, 5).join(", ")}${other.length > 5 ? "..." : ""}`);
+    }
+    const objectGroups = {
+        core,
+        dependency,
+        reference,
+        other,
+        stats: {
+            total: objects.length,
+            core_count: core.length,
+            dependency_count: dependency.length,
+            reference_count: reference.length,
+            other_count: other.length,
+            by_type: objects.reduce((acc, o) => {
+                const t = o.objectType ?? "unknown";
+                const prefix = t.includes("::") ? t.split("::")[0].toLowerCase() : t.toLowerCase();
+                acc[prefix] = (acc[prefix] ?? 0) + 1;
+                return acc;
+            }, {}),
+        },
+    };
     return {
         action: "get_project_detail",
-        project,
+        project: effectiveProject,
         objects,
+        objectGroups,
         graphEdgeCount: edges.length,
+        serviceStatus,
         evaluations: evaluations.map(e => ({
             id: e.id,
             evalType: e.evalType,
             score: e.score,
             summary: e.summary,
+            details: e.details,
             evaluatedAt: e.evaluatedAt,
         })),
         versions: versions.map(v => ({
@@ -175,16 +457,72 @@ export async function handleGetProjectDetail(v) {
         })),
     };
 }
+const SHORT_TO_FULL_TYPE = {
+    "Service": "0x2::service::Service",
+    "Machine": "0x2::machine::Machine",
+    "Guard": "0x2::guard::Guard",
+    "Permission": "0x2::permission::Permission",
+    "Reward": "0x2::reward::Reward",
+    "Arbitration": "0x2::arbitration::Arbitration",
+    "Progress": "0x2::progress::Progress",
+    "Treasury": "0x2::treasury::Treasury",
+    "Demand": "0x2::demand::Demand",
+    "Repository": "0x2::repository::Repository",
+    "Contact": "0x2::contact::Contact",
+    "Order": "0x2::order::Order",
+    "Allocation": "0x2::allocation::Allocation",
+    "Personal": "0x2::personal::Personal",
+    "Payment": "0x2::payment::Payment",
+    "Proof": "0x2::proof::Proof",
+};
 export async function handleAddObject(v) {
     const projectId = await resolveProjectId(v);
     const objectAddress = await resolveObjectAddress(v);
+    const rawType = v.object_type_add;
+    const objectType = rawType
+        ? (rawType.includes("::") ? rawType : (SHORT_TO_FULL_TYPE[rawType] ?? rawType))
+        : undefined;
+    let objectName = v.object_name_add;
+    let role = v.object_role;
+    if (!objectName) {
+        const marks = await LocalMark.Instance().list({ address: objectAddress });
+        if (marks.length > 0 && marks[0].name) {
+            objectName = marks[0].name;
+        }
+    }
+    if (!role) {
+        const objType = objectType ?? "";
+        if (objType.includes("service::Service")) {
+            role = "core";
+        }
+        else if (objType.includes("::") && (objType.includes("permission::") ||
+            objType.includes("machine::") ||
+            objType.includes("guard::") ||
+            objType.includes("reward::") ||
+            objType.includes("treasury::") ||
+            objType.includes("allocation::") ||
+            objType.includes("progress::") ||
+            objType.includes("arbitration::") ||
+            objType.includes("demand::") ||
+            objType.includes("order::") ||
+            objType.includes("repository::"))) {
+            role = "dependency";
+        }
+        else {
+            role = "reference";
+        }
+    }
     const obj = await localProject.addObject(projectId, {
         objectAddress,
-        objectType: v.object_type_add,
-        objectName: v.object_name_add,
-        role: v.object_role ?? "reference",
+        objectType,
+        objectName,
+        role,
         tags: v.object_tags_add,
     });
+    const project = await localProject.getProject(projectId);
+    if (project && project.status === "draft") {
+        await localProject.updateProject(projectId, { status: "active" });
+    }
     return { action: "add_object", object: obj };
 }
 export async function handleRemoveObject(v) {
@@ -227,20 +565,43 @@ export async function handleBuildGraph(v) {
     const project = await localProject.getProject(projectId);
     if (!project)
         throw new Error(`Project not found: ${projectId}`);
+    if (v.async_mode === true) {
+        const taskId = TaskTracker.create("build_graph", projectId);
+        (async () => {
+            try {
+                TaskTracker.update(taskId, 10, "Resolving root address");
+                const result = await buildGraphSync(projectId, project, v);
+                TaskTracker.complete(taskId, result);
+            }
+            catch (err) {
+                TaskTracker.fail(taskId, err.message ?? String(err));
+            }
+        })();
+        return {
+            action: "build_graph",
+            async_mode: true,
+            task_id: taskId,
+            hint: "Graph is building in the background. Call query_task_status with task_id to check progress and retrieve the result.",
+        };
+    }
+    return buildGraphSync(projectId, project, v);
+}
+async function buildGraphSync(projectId, project, v) {
     let rootAddress = project.serviceAddress;
     if (!rootAddress) {
         const objects = await localProject.listObjects(projectId);
         if (objects.length === 0) {
             throw new Error("Cannot build graph: project has no objects and no service_address");
         }
-        rootAddress = objects[0].objectAddress;
+        const coreObj = objects.find(o => o.role === "core");
+        rootAddress = (coreObj ?? objects[0]).objectAddress;
     }
     const builder = new GraphBuilder({
-        maxDepth: v.max_depth ?? 3,
+        maxDepth: v.max_depth ?? v.depth ?? 3,
         enableRegistrar: v.enable_registrar ?? true,
         enablePotential: v.enable_potential ?? false,
         projectId,
-        network: project.network,
+        network: project.network ?? undefined,
     });
     const result = await builder.buildRelationshipGraph(rootAddress);
     const edgesBySource = {};
@@ -248,6 +609,19 @@ export async function handleBuildGraph(v) {
         const src = edge.edgeSource ?? "unknown";
         edgesBySource[src] = (edgesBySource[src] ?? 0) + 1;
     }
+    const topEdges = result.graph.edges
+        .slice()
+        .sort((a, b) => (b.weight ?? 0) - (a.weight ?? 0))
+        .slice(0, 5)
+        .map(e => ({
+        source: e.sourceObject,
+        target: e.targetObject,
+        fieldName: e.fieldName,
+        relationshipType: e.relationshipType,
+        weight: e.weight,
+        verified: e.verified,
+    }));
+    const visualization = topEdges.map(e => `  ${shortLabel(e.source)} --${e.fieldName ?? e.relationshipType ?? ""}--> ${shortLabel(e.target)}`).join("\n");
     return {
         action: "build_graph",
         nodeCount: result.graph.nodes.length,
@@ -255,8 +629,74 @@ export async function handleBuildGraph(v) {
         edgesBySource,
         reputationCount: result.reputation.size,
         builtAt: result.graph.builtAt,
+        topEdges,
+        visualization: visualization || "  (no edges to display)",
+        hint: `Showing top ${topEdges.length} critical edges. Call project_operation with action='get_graph' to list all ${result.graph.edges.length} edges.`,
+        binding_verification: await verifyServiceBindings(project.serviceAddress, project.network),
     };
 }
+async function verifyServiceBindings(serviceAddress, network) {
+    if (!serviceAddress)
+        return null;
+    try {
+        const response = await query_objects({
+            objects: [serviceAddress],
+            network: network,
+        });
+        const svc = response?.objects?.[0];
+        if (!svc)
+            return null;
+        const allocCount = svc.order_allocators?.allocators?.length ?? 0;
+        const arbCount = Array.isArray(svc.arbitrations) ? svc.arbitrations.length : 0;
+        const bindings = {
+            "Service.machine": {
+                expected: "Machine",
+                actual: svc.machine ?? null,
+                verified: !!svc.machine,
+            },
+            "Service.permission": {
+                expected: "Permission",
+                actual: svc.permission ?? null,
+                verified: !!svc.permission,
+            },
+            "Service.buy_guard": {
+                expected: "Guard",
+                actual: svc.buy_guard ?? null,
+                verified: !!svc.buy_guard,
+            },
+            "Service.order_allocators": {
+                expected: "Guard[]",
+                actual: null,
+                count: allocCount,
+                verified: allocCount > 0,
+            },
+            "Service.arbitrations": {
+                expected: "Arbitration[]",
+                actual: null,
+                count: arbCount,
+                verified: arbCount > 0,
+            },
+            "Service.um": {
+                expected: "Contact",
+                actual: svc.um ?? null,
+                verified: !!svc.um,
+            },
+        };
+        const all_verified = Object.values(bindings).every((b) => b.verified);
+        return { service: serviceAddress, bindings, all_verified };
+    }
+    catch {
+        return null;
+    }
+}
+function shortLabel(addrOrName) {
+    if (!addrOrName)
+        return "(empty)";
+    if (!addrOrName.startsWith("0x")) {
+        return addrOrName.length <= 24 ? addrOrName : addrOrName.slice(0, 21) + "...";
+    }
+    return addrOrName.length <= 12 ? addrOrName : addrOrName.slice(0, 10) + "..";
+}
 export async function handleGetGraph(v) {
     const projectId = await resolveProjectId(v);
     const edges = await localProject.getGraph(projectId);
@@ -438,6 +878,58 @@ export async function handleDeleteProject(v) {
     await localProject.deleteProject(id);
     return { action: "delete_project", deleted: true };
 }
+export async function handleCloneProjectToNetwork(v) {
+    const sourceProjectId = await resolveProjectId(v);
+    const sourceProject = await localProject.getProject(sourceProjectId);
+    if (!sourceProject) {
+        throw new Error(`Source project not found: ${sourceProjectId}`);
+    }
+    const targetNetwork = requireField(v.target_network, "target_network");
+    if (!["testnet", "mainnet"].includes(targetNetwork)) {
+        throw new Error("target_network must be 'testnet' or 'mainnet'");
+    }
+    const actionName = (v.action === "migrate_network" ? "migrate_network" : "clone_project_to_network");
+    const newPrefix = `${sourceProject.prefix}_${targetNetwork}`;
+    const existing = await localProject.getProjectByPrefix(newPrefix);
+    if (existing) {
+        throw new Error(`Target project prefix '${newPrefix}' already exists (project: '${existing.name}', id: '${existing.id}'). ` +
+            `Use update_project on the existing target or delete it first.`);
+    }
+    const newProject = await localProject.createProject({
+        prefix: newPrefix,
+        name: `${sourceProject.name} (${targetNetwork})`,
+        description: sourceProject.description ?? undefined,
+        industry: sourceProject.industry ?? undefined,
+        perspective: sourceProject.perspective ?? "producer",
+        labels: sourceProject.labels ?? undefined,
+        network: targetNetwork,
+    });
+    const sourceObjects = await localProject.listObjects(sourceProjectId);
+    let clonedCount = 0;
+    for (const obj of sourceObjects) {
+        await localProject.addObject(newProject.id, {
+            objectAddress: `draft:${obj.objectName ?? "unnamed"}`,
+            objectType: obj.objectType !== null ? obj.objectType : undefined,
+            objectName: obj.objectName !== null ? obj.objectName : undefined,
+            role: obj.role ?? "dependency",
+            metadata: {
+                status: "draft",
+                cloned_from: sourceProjectId,
+                cloned_at: Date.now(),
+            },
+        });
+        clonedCount++;
+    }
+    return {
+        action: actionName,
+        new_project_id: newProject.id,
+        new_prefix: newPrefix,
+        target_network: targetNetwork,
+        cloned_objects_count: clonedCount,
+        message: `Project '${sourceProject.prefix}' cloned to ${targetNetwork} as '${newPrefix}'. ${clonedCount} object(s) copied as drafts — object addresses are empty pending on-chain deployment.`,
+        next_steps: `Execute the same onchain_operations sequence with env.network='${targetNetwork}' to deploy objects. Then call update_project to set service_address, and build_graph to construct the new project's relationship graph.`,
+    };
+}
 export async function handleGetObjectDiff(v) {
     const address = requireField(v.diff_address, "diff_address");
     const fromTime = requireField(v.diff_from_time, "diff_from_time");
@@ -456,3 +948,430 @@ export async function handleGetObjectDiff(v) {
         })),
     };
 }
+function normalizeForwards(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((f) => {
+        const guardObj = f?.guard;
+        const isGuardObj = guardObj && typeof guardObj === "object" && typeof guardObj.guard === "string";
+        const guardAddress = isGuardObj
+            ? guardObj.guard
+            : typeof guardObj === "string" ? guardObj : null;
+        const retainedSubmission = isGuardObj && Array.isArray(guardObj.retained_submission)
+            ? guardObj.retained_submission
+            : null;
+        return {
+            name: typeof f?.name === "string" ? f.name : "",
+            weight: typeof f?.weight === "number" ? f.weight : 0,
+            guard: guardAddress,
+            retained_submission: retainedSubmission,
+            named_operator: typeof f?.namedOperator === "string" ? f.namedOperator : null,
+            permission_index: typeof f?.permissionIndex === "number" ? f.permissionIndex : null,
+        };
+    });
+}
+export async function handleGetMachineGraph(v) {
+    const projectId = await resolveProjectId(v);
+    const machineAddress = await resolveObjectAddress(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found (id: ${projectId})`);
+    const objects = await localProject.listObjects(projectId);
+    const machineObj = objects.find(o => o.objectAddress === machineAddress);
+    if (!machineObj) {
+        throw new Error(`Object ${machineAddress} is not part of project '${project.prefix}'. ` +
+            `Add it via add_object first.`);
+    }
+    const network = (project.network ?? "testnet");
+    let machineData = null;
+    try {
+        const queryResult = await query_objects({
+            objects: [machineAddress],
+            network,
+        });
+        machineData = queryResult?.objects?.[0] ?? null;
+    }
+    catch (e) {
+        throw new Error(`Failed to query Machine on ${network}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!machineData) {
+        throw new Error(`Machine ${machineAddress} not found on ${network}. ` +
+            `It may not exist on this network — try switching networks.`);
+    }
+    let machineName = null;
+    const marks = await LocalMark.Instance().list({ address: machineAddress });
+    if (marks.length > 0 && marks[0].name) {
+        machineName = marks[0].name;
+    }
+    const published = typeof machineData.bPublished === "boolean" ? machineData.bPublished : null;
+    const paused = typeof machineData.bPaused === "boolean" ? machineData.bPaused : null;
+    const nodeMap = new Map();
+    const edgeList = [];
+    let rawNodes = [];
+    try {
+        const allFieldObjectIds = [];
+        let cursor = undefined;
+        for (;;) {
+            const tableResult = await query_table({
+                parent: machineAddress,
+                cursor: cursor ?? undefined,
+                network,
+            });
+            if (!tableResult?.items || tableResult.items.length === 0)
+                break;
+            for (const item of tableResult.items) {
+                if (item.object)
+                    allFieldObjectIds.push(item.object);
+            }
+            if (!tableResult.hasNextPage || !tableResult.nextCursor)
+                break;
+            cursor = tableResult.nextCursor;
+        }
+        if (allFieldObjectIds.length > 0) {
+            const BATCH = 50;
+            for (let i = 0; i < allFieldObjectIds.length; i += BATCH) {
+                const batch = allFieldObjectIds.slice(i, i + BATCH);
+                const nodeQueryResult = await query_objects({
+                    objects: batch,
+                    network,
+                });
+                for (const obj of nodeQueryResult?.objects ?? []) {
+                    if (obj.type === "TableItem_MachineNode") {
+                        rawNodes.push(obj);
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        throw new Error(`Failed to query Machine nodes on ${network}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    for (const nodeObj of rawNodes) {
+        const nodeName = nodeObj.name;
+        if (!nodeName)
+            continue;
+        if (!nodeMap.has(nodeName)) {
+            nodeMap.set(nodeName, { name: nodeName, description: null });
+        }
+        const pairs = Array.isArray(nodeObj.value) ? nodeObj.value : [];
+        for (const pair of pairs) {
+            if (!pair || typeof pair !== "object")
+                continue;
+            const from = typeof pair.prev_node === "string" ? pair.prev_node : "";
+            if (!from)
+                continue;
+            const to = nodeName;
+            const threshold = typeof pair.threshold === "number" ? pair.threshold : 1;
+            const forwards = normalizeForwards(pair.forwards);
+            edgeList.push({ from, to, threshold, forwards });
+        }
+    }
+    for (const edge of edgeList) {
+        if (!nodeMap.has(edge.from)) {
+            nodeMap.set(edge.from, { name: edge.from, description: null });
+        }
+        if (!nodeMap.has(edge.to)) {
+            nodeMap.set(edge.to, { name: edge.to, description: null });
+        }
+    }
+    return {
+        action: "get_machine_graph",
+        machineAddress,
+        machineName,
+        nodes: Array.from(nodeMap.values()),
+        edges: edgeList,
+        published,
+        paused,
+    };
+}
+export async function handlePreEvaluateCheck(v) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const missing = [];
+    const warnings = [];
+    const objects = await localProject.listObjects(projectId);
+    if (objects.length === 0) {
+        missing.push({
+            id: "PE-01",
+            description: "Project has no objects (project_objects table is empty).",
+            impact: "Evaluator will return a neutral score with no findings. " +
+                "Call add_object or create_project_from_onchain first.",
+        });
+        return {
+            action: "pre_evaluate_check",
+            ready: false,
+            missing,
+            warnings,
+            summary: "Project is empty — add objects before evaluating.",
+        };
+    }
+    const edges = await localProject.getGraph(projectId);
+    if (edges.length === 0) {
+        warnings.push({
+            id: "PE-02",
+            description: "Project has no graph edges (graph_edges table is empty).",
+            impact: "Evaluator's binding-based checks (machine, permission, " +
+                "buy_guard, order_allocators) will return 0. Call build_graph " +
+                "before evaluate_project to populate edges.",
+        });
+    }
+    const addresses = objects.map(o => o.objectAddress);
+    const cacheEntries = await localProject.getCachedObjects(addresses);
+    const uncached = [];
+    let staleCount = 0;
+    const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    for (const o of objects) {
+        const entry = cacheEntries.get(o.objectAddress);
+        if (!entry) {
+            uncached.push(o.objectAddress);
+        }
+        else {
+            const fetchedAt = entry?.fetchedAt;
+            if (typeof fetchedAt === "number" && (now - fetchedAt) > STALE_THRESHOLD_MS) {
+                staleCount++;
+            }
+        }
+    }
+    if (uncached.length > 0) {
+        warnings.push({
+            id: "PE-03",
+            description: `${uncached.length}/${objects.length} project objects have no cached on-chain data.`,
+            impact: "Evaluator will see empty object data for these objects. " +
+                "Call refresh_objects before evaluate_project to fetch fresh data.",
+        });
+    }
+    if (staleCount > 0) {
+        warnings.push({
+            id: "PE-04",
+            description: `${staleCount}/${objects.length} project objects have cache older than 24 hours.`,
+            impact: "Evaluator results may be based on stale state. " +
+                "Call refresh_objects to fetch fresh data.",
+        });
+    }
+    const knownAddresses = new Set(objects.map(o => o.objectAddress));
+    const knownNames = new Set(objects.map(o => o.objectName).filter(Boolean));
+    const danglingEdges = edges.filter((e) => !knownAddresses.has(e.sourceObject) && !knownNames.has(e.sourceObject)
+        && !knownAddresses.has(e.targetObject) && !knownNames.has(e.targetObject));
+    if (danglingEdges.length > 0) {
+        warnings.push({
+            id: "PE-05",
+            description: `${danglingEdges.length} graph edges reference objects not in project_objects.`,
+            impact: "Evaluator's binding index may include stale/dangling entries. " +
+                "Call build_graph again to refresh edges, or remove orphan objects.",
+        });
+    }
+    if (project.perspective === "producer") {
+        const hasService = objects.some(o => o.objectType === "service");
+        if (!hasService) {
+            missing.push({
+                id: "PE-06",
+                description: "Producer project has no Service-type object.",
+                impact: "Evaluator's service-centric checks (publish state, " +
+                    "machine binding, order_allocators, etc.) will all return 0. " +
+                    "Add a Service object or import one via create_project_from_onchain.",
+            });
+        }
+    }
+    const draftCount = objects.filter((o) => {
+        const meta = (o.metadata ?? {});
+        return meta.status === "draft" || o.objectAddress.startsWith("draft:");
+    }).length;
+    if (draftCount === objects.length && objects.length > 0) {
+        warnings.push({
+            id: "PE-07",
+            description: `All ${objects.length} objects are draft (not yet on-chain).`,
+            impact: "Evaluator will assess the blueprint as if it were on-chain. " +
+                "Real on-chain state may differ once deployed.",
+        });
+    }
+    const ready = missing.length === 0;
+    const summary = ready
+        ? (warnings.length === 0
+            ? `Ready to evaluate. ${objects.length} objects, ${edges.length} edges.`
+            : `Ready to evaluate with ${warnings.length} warning(s). ${objects.length} objects, ${edges.length} edges.`)
+        : `Not ready: ${missing.length} blocking issue(s) found.`;
+    return {
+        action: "pre_evaluate_check",
+        ready,
+        missing,
+        warnings,
+        summary,
+        counts: {
+            objects: objects.length,
+            edges: edges.length,
+            uncached: uncached.length,
+            stale: staleCount,
+            dangling_edges: danglingEdges.length,
+            drafts: draftCount,
+        },
+    };
+}
+export async function handleVerifyDeployment(v) {
+    const projectId = await resolveProjectId(v);
+    const project = await localProject.getProject(projectId);
+    if (!project)
+        throw new Error(`Project not found: ${projectId}`);
+    const objects = await localProject.listObjects(projectId);
+    if (objects.length === 0) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: 0,
+            results: [],
+            summary: "Project has no objects to verify.",
+        };
+    }
+    const network = (project.network ?? "testnet");
+    const deployedObjects = objects.filter((o) => !o.objectAddress.startsWith("draft:") && o.objectAddress.startsWith("0x"));
+    if (deployedObjects.length === 0) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: 0,
+            results: [],
+            summary: `All ${objects.length} objects are draft or non-address — nothing to verify on-chain.`,
+        };
+    }
+    const batchSize = Math.min(deployedObjects.length, 50);
+    const addressesToQuery = deployedObjects.slice(0, batchSize).map(o => o.objectAddress);
+    let chainResult;
+    try {
+        chainResult = await query_objects({
+            objects: addressesToQuery,
+            network,
+        });
+    }
+    catch (e) {
+        return {
+            action: "verify_deployment",
+            verifiedCount: 0,
+            matched: 0,
+            mismatched: 0,
+            missing: 0,
+            unreachable: deployedObjects.length,
+            results: deployedObjects.map(o => ({
+                objectAddress: o.objectAddress,
+                objectName: o.objectName,
+                objectType: o.objectType,
+                status: "unreachable",
+                error: e instanceof Error ? e.message : String(e),
+            })),
+            summary: `Failed to query on-chain state: ${e instanceof Error ? e.message : String(e)}`,
+        };
+    }
+    const chainObjects = chainResult?.objects ?? [];
+    const chainByAddress = new Map();
+    for (const co of chainObjects) {
+        if (co && typeof co === "object" && "objectId" in co) {
+            chainByAddress.set(co.objectId, co);
+        }
+    }
+    const results = [];
+    let matched = 0, mismatched = 0, missing = 0;
+    for (const obj of deployedObjects.slice(0, batchSize)) {
+        const chainObj = chainByAddress.get(obj.objectAddress);
+        if (!chainObj) {
+            missing++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "missing",
+            });
+            continue;
+        }
+        const chainData = chainObj;
+        const sqliteData = (await localProject.getCachedObjects([obj.objectAddress])).get(obj.objectAddress);
+        const sqliteFields = sqliteData?.data ?? {};
+        const differences = [];
+        let bindings;
+        if (obj.objectType === "service") {
+            const fieldsToCompare = ["machine", "permission", "buy_guard", "arbitrations", "rewards", "repositories"];
+            for (const f of fieldsToCompare) {
+                const sqliteVal = sqliteFields[f];
+                const chainVal = chainData[f];
+                const norm = (v) => (v === null || v === undefined || v === "") ? null : v;
+                if (JSON.stringify(norm(sqliteVal)) !== JSON.stringify(norm(chainVal))) {
+                    differences.push({ field: f, sqlite: sqliteVal, onchain: chainVal });
+                }
+            }
+            bindings = {
+                machine: !!chainData.machine,
+                permission: !!chainData.permission,
+                buy_guard: !!chainData.buy_guard,
+                order_allocators: !!chainData.order_allocators,
+            };
+            if (sqliteFields.bPublished !== undefined && chainData.bPublished !== undefined
+                && sqliteFields.bPublished !== chainData.bPublished) {
+                differences.push({
+                    field: "bPublished",
+                    sqlite: sqliteFields.bPublished,
+                    onchain: chainData.bPublished,
+                });
+            }
+        }
+        else if (obj.objectType === "machine") {
+            if (sqliteFields.bPublished !== undefined && chainData.bPublished !== undefined
+                && sqliteFields.bPublished !== chainData.bPublished) {
+                differences.push({
+                    field: "bPublished",
+                    sqlite: sqliteFields.bPublished,
+                    onchain: chainData.bPublished,
+                });
+            }
+            const sqliteNodeCount = sqliteFields.node_count;
+            const chainNodeCount = chainData.node_count;
+            if (sqliteNodeCount !== undefined && chainNodeCount !== undefined
+                && sqliteNodeCount !== chainNodeCount) {
+                differences.push({
+                    field: "node_count",
+                    sqlite: sqliteNodeCount,
+                    onchain: chainNodeCount,
+                });
+            }
+        }
+        if (differences.length > 0) {
+            mismatched++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "mismatched",
+                differences,
+                bindings,
+            });
+        }
+        else {
+            matched++;
+            results.push({
+                objectAddress: obj.objectAddress,
+                objectName: obj.objectName,
+                objectType: obj.objectType,
+                status: "matched",
+                bindings,
+            });
+        }
+    }
+    const summary = matched === deployedObjects.length
+        ? `All ${matched} deployed objects verified.`
+        : `${matched} matched, ${mismatched} mismatched, ${missing} missing.`;
+    return {
+        action: "verify_deployment",
+        verifiedCount: results.length,
+        matched,
+        mismatched,
+        missing,
+        unreachable: 0,
+        results,
+        summary,
+    };
+}