@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/project/intent-analyzer.d.ts

@@ -0,0 +1,71 @@
+import type { IndustryTraits } from "../knowledge/industry-registry.js";
+export type BusinessIntentType = "sell_service" | "sell_product" | "sell_subscription" | "rent_asset" | "crowdfund" | "escrow";
+export interface RoleDefinition {
+    name: string;
+    description: string;
+    obligations: string[];
+    rights: string[];
+}
+export interface DeliverableDefinition {
+    name: string;
+    type: "digital" | "physical" | "service_session" | "access_right";
+    acceptanceCriteria: string;
+    proofOfDelivery: "manual_confirm" | "wip_hash" | "third_party_attestation" | "auto_verify";
+}
+export interface PaymentTrigger {
+    event: string;
+    guardDescription: string;
+}
+export interface PaymentAllocation {
+    recipient: string;
+    percentage: number;
+}
+export interface PaymentIntent {
+    model: "milestone" | "upfront" | "subscription" | "per_use" | "escrow";
+    currency: string;
+    triggers: PaymentTrigger[];
+    allocation?: PaymentAllocation[];
+}
+export interface TrustIntent {
+    refundPolicy: "no_refund" | "partial" | "full" | "milestone_prorated";
+    arbitration: "none" | "merchant_pick" | "mutual_pick" | "third_party";
+    escrow: boolean;
+    transparency: "minimal" | "standard" | "full";
+}
+export interface TimelineMilestone {
+    name: string;
+    description: string;
+    duration: string;
+}
+export interface TimelineIntent {
+    totalDuration?: string;
+    milestones?: TimelineMilestone[];
+}
+export interface BusinessIntent {
+    intent: BusinessIntentType;
+    industry?: string;
+    description: string;
+    roles: {
+        merchant: RoleDefinition;
+        customer: RoleDefinition;
+        suppliers?: RoleDefinition[];
+        arbitrators?: RoleDefinition;
+    };
+    deliverables: DeliverableDefinition[];
+    payment: PaymentIntent;
+    trust: TrustIntent;
+    timeline?: TimelineIntent;
+}
+export interface IntentAnalysisResult {
+    intent: BusinessIntent;
+    inferredIndustry: string;
+    industryConfidence: number;
+    similarIndustries: string[];
+    inferredTraits: IndustryTraits;
+    recommendedModules: string[];
+    warnings: string[];
+}
+export declare function analyzeIntent(description: string, options?: {
+    preferredIndustry?: string;
+    currency?: string;
+}): Promise<IntentAnalysisResult>;

package/dist/project/intent-analyzer.js

@@ -0,0 +1,149 @@
+import { findSimilarIndustries, inferTraitsFromDescription } from "../knowledge/industry-generalizer.js";
+const INTENT_KEYWORDS = {
+    sell_service: ["design", "develop", "consult", "freelance", "service", "build", "create", "write", "translate"],
+    sell_product: ["sell", "product", "item", "goods", "merchandise", "store", "shop"],
+    sell_subscription: ["subscribe", "subscription", "membership", "monthly", "recurring", "creator", "patron"],
+    rent_asset: ["rent", "rental", "lease", "borrow", "car", "house", "apartment", "equipment"],
+    crowdfund: ["crowdfund", "fund", "raise", "campaign", "donation", "backer"],
+    escrow: ["escrow", "hold", "mediate", "intermediary", "safe", "secure transaction"],
+};
+function classifyIntentType(description) {
+    const lower = description.toLowerCase();
+    let bestType = "sell_service";
+    let bestScore = 0;
+    for (const [type, keywords] of Object.entries(INTENT_KEYWORDS)) {
+        const score = keywords.filter((k) => lower.includes(k)).length;
+        if (score > bestScore) {
+            bestScore = score;
+            bestType = type;
+        }
+    }
+    return bestType;
+}
+function inferPaymentModel(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("milestone") || lower.includes("phase") || lower.includes("stage"))
+        return "milestone";
+    if (lower.includes("subscription") || lower.includes("monthly") || lower.includes("recurring"))
+        return "subscription";
+    if (lower.includes("per use") || lower.includes("hourly") || lower.includes("per session"))
+        return "per_use";
+    if (lower.includes("escrow") || lower.includes("hold"))
+        return "escrow";
+    return "upfront";
+}
+function inferRefundPolicy(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("no refund") || lower.includes("non-refundable"))
+        return "no_refund";
+    if (lower.includes("milestone") && lower.includes("refund"))
+        return "milestone_prorated";
+    if (lower.includes("full refund"))
+        return "full";
+    return "partial";
+}
+function inferArbitration(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("no arbitration") || lower.includes("no dispute"))
+        return "none";
+    if (lower.includes("third party") || lower.includes("independent"))
+        return "third_party";
+    if (lower.includes("mutual"))
+        return "mutual_pick";
+    return "merchant_pick";
+}
+export async function analyzeIntent(description, options) {
+    const warnings = [];
+    const intentType = classifyIntentType(description);
+    const traitInference = inferTraitsFromDescription(description);
+    const similarMatches = findSimilarIndustries(traitInference.traits, 3);
+    const similarIndustries = similarMatches.map((m) => m.industry);
+    const inferredIndustry = options?.preferredIndustry ?? similarIndustries[0] ?? "general";
+    const industryConfidence = similarIndustries.includes(inferredIndustry) ? 0.85 : 0.5;
+    const inferredTraits = traitInference.traits;
+    const intent = {
+        intent: intentType,
+        industry: inferredIndustry,
+        description,
+        roles: {
+            merchant: {
+                name: "merchant",
+                description: "Service provider or seller",
+                obligations: ["Deliver as described", "Maintain compensation_fund if required", "Accept arbitration verdicts"],
+                rights: ["Receive payment upon verified delivery", "Set service terms before publish"],
+            },
+            customer: {
+                name: "customer",
+                description: "Buyer or service recipient",
+                obligations: ["Pay according to agreed schedule", "Provide acceptance/rejection within timeout"],
+                rights: ["Receive deliverables as described", "Request refund if delivery fails", "Initiate arbitration for disputes"],
+            },
+        },
+        deliverables: [
+            {
+                name: "main_deliverable",
+                type: inferDeliverableType(description),
+                acceptanceCriteria: "To be defined by merchant during configuration",
+                proofOfDelivery: "wip_hash",
+            },
+        ],
+        payment: {
+            model: inferPaymentModel(description),
+            currency: options?.currency ?? "WOW",
+            triggers: [
+                {
+                    event: inferPaymentModel(description) === "milestone" ? "milestone completion" : "service confirmation",
+                    guardDescription: "Guard verifies deliverable meets acceptance criteria",
+                },
+            ],
+            allocation: [
+                { recipient: "merchant", percentage: 90 },
+                { recipient: "platform", percentage: 0 },
+                { recipient: "arbitration_reserve", percentage: 10 },
+            ],
+        },
+        trust: {
+            refundPolicy: inferRefundPolicy(description),
+            arbitration: inferArbitration(description),
+            escrow: true,
+            transparency: "full",
+        },
+    };
+    if (intent.payment.model === "milestone" && !description.toLowerCase().includes("milestone")) {
+        warnings.push("Payment model inferred as 'milestone' but not explicitly mentioned. Please verify.");
+    }
+    if (intent.trust.arbitration === "none") {
+        warnings.push("No arbitration configured. This increases risk for both parties. Consider adding independent_arbitration module.");
+    }
+    if (intent.payment.allocation && intent.payment.allocation.some((a) => a.recipient === "platform" && a.percentage > 0)) {
+        warnings.push("Platform fee > 0 detected. WOW philosophy recommends 0% platform fee for peer-to-peer transactions.");
+    }
+    let recommendedModules = [];
+    try {
+        const { recommendModules } = await import("../extensions/business-modules.js");
+        const modules = recommendModules(inferredIndustry, description, { maxModules: 5 });
+        recommendedModules = modules.map((m) => m.id);
+    }
+    catch {
+        recommendedModules = ["milestone_escrow", "independent_arbitration", "wip_provenance"];
+    }
+    return {
+        intent,
+        inferredIndustry,
+        industryConfidence,
+        similarIndustries,
+        inferredTraits,
+        recommendedModules,
+        warnings,
+    };
+}
+function inferDeliverableType(description) {
+    const lower = description.toLowerCase();
+    if (lower.includes("design") || lower.includes("code") || lower.includes("write") || lower.includes("digital"))
+        return "digital";
+    if (lower.includes("class") || lower.includes("lesson") || lower.includes("session"))
+        return "service_session";
+    if (lower.includes("rent") || lower.includes("access"))
+        return "access_right";
+    return "physical";
+}

package/dist/project/machine-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { ENTRYPOINT, TableItem_MachineNode } from "@wowok/wowok";
+export declare function fetchMachineNodes(machineAddress: string, network: ENTRYPOINT): Promise<TableItem_MachineNode[]>;

package/dist/project/machine-nodes.js

@@ -0,0 +1,36 @@
+import { query_objects, query_table } from "@wowok/wowok";
+const BATCH = 50;
+export async function fetchMachineNodes(machineAddress, network) {
+    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;
+    }
+    const rawNodes = [];
+    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);
+            }
+        }
+    }
+    return rawNodes;
+}

package/dist/project/merchant-guide.d.ts

@@ -0,0 +1,165 @@
+import { type BusinessIntent, type DeliverableDefinition, type PaymentIntent, type TrustIntent } from "./intent-analyzer.js";
+import { type BusinessModuleId } from "../extensions/business-modules.js";
+export interface GuideState {
+    intent_text: string;
+    confirmed_industry?: string;
+    currency?: string;
+    deliverables?: DeliverableDefinition[];
+    payment_override?: Partial<PaymentIntent>;
+    trust_override?: Partial<TrustIntent>;
+    adopted_module_ids?: BusinessModuleId[];
+}
+export interface MerchantGuideInput {
+    intent?: string;
+    guide_state?: {
+        intent_text: string;
+        confirmed_industry?: string;
+        currency?: string;
+        deliverables?: unknown[];
+        payment_override?: Record<string, unknown>;
+        trust_override?: Record<string, unknown>;
+        adopted_module_ids?: string[];
+    };
+    guide_confirm?: {
+        industry?: string;
+        currency?: string;
+        deliverables?: unknown[];
+        payment?: Record<string, unknown>;
+        trust?: Record<string, unknown>;
+        adopted_module_ids?: string[];
+    };
+}
+interface CreationPlanEntry {
+    order: number;
+    node_id: string;
+    object_type: string;
+    suggested_name: string;
+    depends_on: string[];
+    operation_hint: string;
+}
+export declare function handleMerchantGuide(v: MerchantGuideInput): Promise<{
+    action: "merchant_guide";
+    current_step: number;
+    step_name: string;
+    guide_state: GuideState;
+    intent_draft: BusinessIntent;
+    industry_options: {
+        inferred: string;
+        confidence: number;
+        similar: string[];
+    };
+    warnings: string[];
+    next_action: string;
+    intent?: undefined;
+    adopted_modules?: undefined;
+    blueprint?: undefined;
+    evaluation_preview?: undefined;
+    graph_validation?: undefined;
+    harness_check?: undefined;
+    game_theory?: undefined;
+    creation_plan?: undefined;
+} | {
+    action: "merchant_guide";
+    current_step: number;
+    step_name: string;
+    guide_state: {
+        adopted_module_ids: BusinessModuleId[];
+        intent_text: string;
+        confirmed_industry?: string;
+        currency?: string;
+        deliverables?: DeliverableDefinition[];
+        payment_override?: Partial<PaymentIntent>;
+        trust_override?: Partial<TrustIntent>;
+    };
+    intent: {
+        intent_type: import("./intent-analyzer.js").BusinessIntentType;
+        industry: string | undefined;
+        roles: {
+            merchant: import("./intent-analyzer.js").RoleDefinition;
+            customer: import("./intent-analyzer.js").RoleDefinition;
+            suppliers?: import("./intent-analyzer.js").RoleDefinition[];
+            arbitrators?: import("./intent-analyzer.js").RoleDefinition;
+        };
+        deliverables: DeliverableDefinition[];
+        payment: PaymentIntent;
+        trust: TrustIntent;
+    };
+    adopted_modules: {
+        id: BusinessModuleId;
+        name: string;
+        description: string;
+        requires_keeper: boolean;
+        keeper_hint: string | undefined;
+        user_protections: string[];
+        merchant_obligations: string[];
+    }[];
+    blueprint: {
+        nodes: {
+            id: string;
+            type: import("./namespace.js").ProjectObjectType;
+            purpose: string;
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            relation: string;
+            required: boolean;
+        }[];
+    };
+    evaluation_preview: import("./semantic-graph.js").EvaluationPreview | undefined;
+    graph_validation: {
+        valid: boolean;
+        hard_violations: {
+            id: string;
+            description: string;
+            fix: string;
+        }[];
+        soft_notes: {
+            id: string;
+            description: string;
+        }[];
+    };
+    harness_check: {
+        module_constraints: {
+            module: BusinessModuleId;
+            plan_satisfied: boolean;
+            missing: string[] | undefined;
+            reason: string | undefined;
+            estimated_score_boost: number;
+        }[];
+        blocking_issues: {
+            module: BusinessModuleId;
+            missing_constraints: string[] | undefined;
+            fix: string | undefined;
+        }[];
+        deploy_time_checks: string[];
+    };
+    game_theory: {
+        summary: string;
+        coverage: string;
+        exposed_scenarios: import("./game-theory.js").GameScenario[];
+        wow_alignments: string[];
+        scenarios: {
+            scenario: import("./game-theory.js").GameScenario;
+            covered: boolean;
+            conflict: string;
+            user_protection: string;
+            evaluation_metric: string;
+            recommendation: string | undefined;
+        }[];
+    };
+    creation_plan: CreationPlanEntry[];
+    warnings: string[];
+    next_action: string;
+    intent_draft?: undefined;
+    industry_options?: undefined;
+}>;
+export declare function listBusinessModules(): {
+    id: BusinessModuleId;
+    name: string;
+    description: string;
+    industry_fit: Record<string, number>;
+    addresses_pain_points: string[];
+    requires_keeper: boolean;
+}[];
+export {};

package/dist/project/merchant-guide.js

@@ -0,0 +1,264 @@
+import { analyzeIntent } from "./intent-analyzer.js";
+import { buildSemanticGraph, validateGraph } from "./semantic-graph.js";
+import { checkGameTheoryConstraints } from "./game-theory.js";
+import { CORE_BUSINESS_MODULES, getBusinessModule, recommendModules, checkModuleConstraints, } from "../extensions/business-modules.js";
+function derivePlanSatisfiedConstraints(graph, intent) {
+    const satisfied = new Set();
+    const hasEdge = (rel) => graph.edges.some((e) => e.relation === rel);
+    const hasNode = (id) => graph.nodes.some((n) => n.id === id);
+    const hasNodeType = (t) => graph.nodes.some((n) => n.type === t);
+    const moduleAdopted = (id) => graph.adoptedModules.includes(id);
+    if (hasEdge("has_order_allocators"))
+        satisfied.add("order_allocators_bound");
+    if (hasEdge("uses_machine"))
+        satisfied.add("machine_bound_before_publish");
+    if (hasEdge("has_arbitration"))
+        satisfied.add("arbitration_bound_to_service");
+    if (hasNode("main_machine"))
+        satisfied.add("machine_published");
+    if (hasNode("main_repository"))
+        satisfied.add("repository_published");
+    if (hasNode("main_service"))
+        satisfied.add("service_published");
+    if (hasNode("arb_permission") && hasNode("main_permission")) {
+        satisfied.add("arbitration_permission_independent");
+    }
+    if (moduleAdopted("independent_arbitration") && hasNode("guard_independent_arbitration")) {
+        satisfied.add("voting_guard_configured");
+    }
+    if (moduleAdopted("accept_timeout_protection")) {
+        satisfied.add("time_guard_configured");
+        satisfied.add("adminUnhold_permission");
+    }
+    if (moduleAdopted("milestone_escrow") && hasNodeType("guard")) {
+        satisfied.add("milestone_forward_guarded");
+    }
+    if (hasNode("main_allocation") && intent.payment.allocation && intent.payment.allocation.length > 0) {
+        satisfied.add("allocators_configured");
+        const sum = intent.payment.allocation.reduce((a, p) => a + p.percentage, 0);
+        if (Math.abs(sum - 100) < 0.001)
+            satisfied.add("sharing_sum_100");
+        const platform = intent.payment.allocation.find((p) => p.recipient === "platform");
+        if (platform && platform.percentage === 0)
+            satisfied.add("platform_fee_zero");
+        if (moduleAdopted("supplier_collaboration")) {
+            satisfied.add("allocation_sharing_configured");
+            satisfied.add("demand_configured");
+        }
+    }
+    if (moduleAdopted("wip_provenance") && hasNode("main_repository")) {
+        satisfied.add("wip_hash_before_delivery");
+    }
+    if (moduleAdopted("subscription_with_proof") && hasNode("main_repository")) {
+        satisfied.add("delivery_guard_per_cycle");
+        satisfied.add("repository_updated");
+    }
+    if (moduleAdopted("damage_attestation")) {
+        satisfied.add("pre_rental_hash");
+        satisfied.add("post_rental_hash");
+    }
+    if (moduleAdopted("refund_guarantee")) {
+        satisfied.add("compensation_fund_positive");
+        satisfied.add("refund_guard_configured");
+    }
+    return satisfied;
+}
+function deriveDeployTimeChecks(graph) {
+    const checks = [];
+    if (graph.nodes.some((n) => n.id === "main_machine")) {
+        checks.push("Machine published AND bound to Service BEFORE Service.publish (machine is immutable after publish)");
+    }
+    if (graph.edges.some((e) => e.relation === "has_order_allocators")) {
+        checks.push("Service.order_allocators bound (verify via query_objects after publish — order_allocators is FROZEN at publish)");
+    }
+    if (graph.nodes.some((n) => n.id === "main_arbitration")) {
+        checks.push("Arbitration.permission != Service.permission on-chain (E_ARBITRATION_PERMISSION_CONFLICT=33)");
+    }
+    if (graph.nodes.some((n) => n.id === "main_repository")) {
+        checks.push("Repository published and Guard write validation configured");
+    }
+    checks.push("Run project_operation action='verify_deployment' after materialization to confirm on-chain state matches this plan");
+    return checks;
+}
+function buildCreationPlan(graph) {
+    const entries = [];
+    const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+    const deps = new Map();
+    for (const n of graph.nodes)
+        deps.set(n.id, new Set());
+    for (const e of graph.edges) {
+        if (e.required && deps.has(e.from) && nodeById.has(e.to)) {
+            deps.get(e.from).add(e.to);
+        }
+    }
+    const ordered = [];
+    const remaining = new Map(deps);
+    while (remaining.size > 0) {
+        const ready = [...remaining.entries()].filter(([, d]) => d.size === 0).map(([id]) => id);
+        if (ready.length === 0) {
+            ordered.push(...remaining.keys());
+            break;
+        }
+        ready.sort();
+        for (const id of ready) {
+            ordered.push(id);
+            remaining.delete(id);
+            for (const d of remaining.values())
+                d.delete(id);
+        }
+    }
+    ordered.forEach((id, i) => {
+        const node = nodeById.get(id);
+        const nameCfg = node.config["name"];
+        entries.push({
+            order: i + 1,
+            node_id: id,
+            object_type: node.type,
+            suggested_name: nameCfg?.type === "string" ? nameCfg.value : id,
+            depends_on: [...(deps.get(id) ?? [])],
+            operation_hint: `Create ${node.type} via onchain_operations, then configure. Purpose: ${node.purpose}`,
+        });
+    });
+    return entries;
+}
+export async function handleMerchantGuide(v) {
+    const prior = v.guide_state ?? { intent_text: "" };
+    const confirm = v.guide_confirm ?? {};
+    const state = {
+        intent_text: (v.intent ?? prior.intent_text ?? "").trim(),
+        confirmed_industry: confirm.industry ?? prior.confirmed_industry,
+        currency: confirm.currency ?? prior.currency,
+        deliverables: (confirm.deliverables ?? prior.deliverables),
+        payment_override: (confirm.payment ?? prior.payment_override),
+        trust_override: (confirm.trust ?? prior.trust_override),
+        adopted_module_ids: (confirm.adopted_module_ids ?? prior.adopted_module_ids),
+    };
+    for (const k of Object.keys(state)) {
+        if (state[k] === undefined)
+            delete state[k];
+    }
+    if (!state.intent_text) {
+        throw new Error("merchant_guide requires 'intent' (business description) for Step 1. " +
+            "Example: intent='I want to offer online design service with milestone payments'. " +
+            "Pass the returned guide_state back UNCHANGED on subsequent calls, plus guide_confirm for merchant decisions.");
+    }
+    const analysis = await analyzeIntent(state.intent_text, {
+        preferredIndustry: state.confirmed_industry,
+        currency: state.currency,
+    });
+    if (!state.confirmed_industry) {
+        return {
+            action: "merchant_guide",
+            current_step: 2,
+            step_name: "Industry Matching",
+            guide_state: state,
+            intent_draft: analysis.intent,
+            industry_options: {
+                inferred: analysis.inferredIndustry,
+                confidence: analysis.industryConfidence,
+                similar: analysis.similarIndustries,
+            },
+            warnings: analysis.warnings,
+            next_action: "Confirm the industry by calling merchant_guide again with guide_state (UNCHANGED) " +
+                `plus guide_confirm={ industry: '<one of: ${analysis.similarIndustries.join(", ")} — or any other industry id>' }`,
+        };
+    }
+    const intent = {
+        ...analysis.intent,
+        industry: state.confirmed_industry,
+        deliverables: state.deliverables ?? analysis.intent.deliverables,
+        payment: { ...analysis.intent.payment, ...(state.payment_override ?? {}) },
+        trust: { ...analysis.intent.trust, ...(state.trust_override ?? {}) },
+    };
+    const adoptedModules = state.adopted_module_ids
+        ? state.adopted_module_ids.map((id) => getBusinessModule(id)).filter((m) => !!m)
+        : recommendModules(state.confirmed_industry, state.intent_text, { maxModules: 5 });
+    const graph = buildSemanticGraph(intent, adoptedModules);
+    const validation = validateGraph(graph);
+    const satisfied = derivePlanSatisfiedConstraints(graph, intent);
+    const moduleChecks = adoptedModules.map((m) => checkModuleConstraints(m, satisfied));
+    const deployTimeChecks = deriveDeployTimeChecks(graph);
+    const blockingMissing = moduleChecks.filter((c) => !c.adopted);
+    const gameTheory = checkGameTheoryConstraints(graph, intent);
+    const creationPlan = buildCreationPlan(graph);
+    return {
+        action: "merchant_guide",
+        current_step: blockingMissing.length > 0 ? 9 : 10,
+        step_name: blockingMissing.length > 0 ? "Harness Check (issues found)" : "Submission Plan Ready",
+        guide_state: { ...state, adopted_module_ids: adoptedModules.map((m) => m.id) },
+        intent: {
+            intent_type: intent.intent,
+            industry: intent.industry,
+            roles: intent.roles,
+            deliverables: intent.deliverables,
+            payment: intent.payment,
+            trust: intent.trust,
+        },
+        adopted_modules: adoptedModules.map((m) => ({
+            id: m.id,
+            name: m.name,
+            description: m.description,
+            requires_keeper: m.requiresKeeper,
+            keeper_hint: m.keeperHint,
+            user_protections: m.userProtections,
+            merchant_obligations: m.merchantObligations,
+        })),
+        blueprint: {
+            nodes: graph.nodes.map((n) => ({ id: n.id, type: n.type, purpose: n.purpose })),
+            edges: graph.edges.map((e) => ({ from: e.from, to: e.to, relation: e.relation, required: e.required })),
+        },
+        evaluation_preview: graph.evaluationPreview,
+        graph_validation: {
+            valid: validation.valid,
+            hard_violations: validation.hardViolations.map((c) => ({ id: c.id, description: c.description, fix: c.fixSuggestion })),
+            soft_notes: validation.softViolations.map((c) => ({ id: c.id, description: c.description })),
+        },
+        harness_check: {
+            module_constraints: moduleChecks.map((c) => ({
+                module: c.module,
+                plan_satisfied: c.adopted,
+                missing: c.missingConstraints,
+                reason: c.reason,
+                estimated_score_boost: c.estimatedScoreBoost,
+            })),
+            blocking_issues: blockingMissing.map((c) => ({
+                module: c.module,
+                missing_constraints: c.missingConstraints,
+                fix: c.reason,
+            })),
+            deploy_time_checks: deployTimeChecks,
+        },
+        game_theory: {
+            summary: gameTheory.summary,
+            coverage: `${gameTheory.coveredCount}/${gameTheory.totalCount}`,
+            exposed_scenarios: gameTheory.exposedScenarios,
+            wow_alignments: gameTheory.wowAlignments,
+            scenarios: gameTheory.results.map((r) => ({
+                scenario: r.scenario,
+                covered: r.covered,
+                conflict: r.conflict,
+                user_protection: r.userProtection,
+                evaluation_metric: r.evaluationMetric,
+                recommendation: r.recommendation,
+            })),
+        },
+        creation_plan: creationPlan,
+        warnings: analysis.warnings,
+        next_action: blockingMissing.length > 0
+            ? "Resolve the blocking_issues above (adjust guide_confirm payment/trust/modules, or accept and drop the affected module via guide_confirm.adopted_module_ids), then call merchant_guide again."
+            : "Plan ready. Materialize: 1) create_project with project_industry='" + state.confirmed_industry + "' " +
+                "2) create objects in creation_plan order via onchain_operations " +
+                "3) add_object each on-chain address into the project " +
+                "4) build_graph + evaluate_project 5) verify_deployment.",
+    };
+}
+export function listBusinessModules() {
+    return CORE_BUSINESS_MODULES.map((m) => ({
+        id: m.id,
+        name: m.name,
+        description: m.description,
+        industry_fit: m.industryFit,
+        addresses_pain_points: m.addressesPainPoints,
+        requires_keeper: m.requiresKeeper,
+    }));
+}