@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/project/game-theory.js

@@ -0,0 +1,177 @@
+export const GAME_THEORY_CONSTRAINTS = [
+    {
+        scenario: "merchant_may_deliver_late",
+        conflict: "Merchant incentive: collect payment fast, deliver at own pace (or never). User bears schedule risk with no leverage once funds leave their wallet.",
+        userProtection: {
+            mechanism: "Milestone escrow — funds locked in Order, released per verified milestone",
+            object: "Order + Allocation",
+            guard: "milestone forward guard verifies deliverable before release",
+        },
+        merchantConstraint: {
+            requiredDeposit: true,
+            timeoutPenalty: "compensation_fund covers refund for unstarted milestones",
+        },
+        evaluationMetric: "timeout_protection",
+        mitigationSignals: [
+            ["edge:has_order_allocators", "node:main_machine"],
+            ["module:milestone_escrow"],
+        ],
+        mitigatingModules: ["milestone_escrow", "refund_guarantee"],
+        recommendation: "Adopt milestone_escrow module: bind order_allocators + Machine so funds release only per verified milestone. Add compensation_fund for late-delivery refunds.",
+    },
+    {
+        scenario: "merchant_may_abandon",
+        conflict: "Merchant incentive: maximize intake then abandon the service (exit scam). User has no recourse without locked funds or deposit.",
+        userProtection: {
+            mechanism: "Escrow + compensation fund — user refunds from on-chain fund even if merchant vanishes",
+            object: "Service.compensation_fund + Order",
+            guard: "refund_guard validates claim conditions",
+        },
+        merchantConstraint: {
+            requiredDeposit: true,
+            requiredArbitration: true,
+        },
+        evaluationMetric: "escrow_quality",
+        mitigationSignals: [
+            ["edge:has_order_allocators", "module:refund_guarantee"],
+            ["module:refund_guarantee", "node:main_arbitration"],
+        ],
+        mitigatingModules: ["refund_guarantee", "milestone_escrow", "reputation_on_chain"],
+        recommendation: "Adopt refund_guarantee module: compensation_fund_add > 0 with refund_guard. Escrow via order_allocators prevents merchant from touching funds before delivery.",
+    },
+    {
+        scenario: "customer_may_deny_acceptance",
+        conflict: "Customer incentive: withhold acceptance confirmation to delay payment indefinitely while using the deliverable. Merchant's funds stay locked.",
+        userProtection: {
+            mechanism: "Accept timeout — after N days without response, order auto-advances (adminUnhold) and merchant gets paid",
+            object: "Machine forward + Progress",
+            guard: "time_guard on accept forward",
+        },
+        merchantConstraint: {
+            timeoutPenalty: "user silence past timeout = implicit acceptance",
+        },
+        evaluationMetric: "timeout_protection",
+        mitigationSignals: [
+            ["module:accept_timeout_protection"],
+            ["node:guard_accept_timeout_protection"],
+        ],
+        mitigatingModules: ["accept_timeout_protection"],
+        recommendation: "Adopt accept_timeout_protection module: time_guard on the accept forward (e.g. 7 days) + PROGRESS_UNHOLD permission so the workflow auto-advances on customer silence.",
+    },
+    {
+        scenario: "customer_may_false_claim",
+        conflict: "Customer incentive: claim non-delivery or defect to obtain refund while keeping the goods/service. Merchant loses both deliverable and payment.",
+        userProtection: {
+            mechanism: "WIP provenance — delivery hash committed on-chain before/at delivery; independent arbitration verifies evidence",
+            object: "Repository + Arbitration",
+            guard: "Guard compares proof.signer/proof.time against committed WIP hash",
+        },
+        merchantConstraint: {
+            requiredProof: "wip_hash committed to Repository before fund release",
+            requiredArbitration: true,
+        },
+        evaluationMetric: "proof_integrity",
+        mitigationSignals: [
+            ["node:main_repository", "node:main_arbitration"],
+            ["module:wip_provenance", "node:main_arbitration"],
+        ],
+        mitigatingModules: ["wip_provenance", "independent_arbitration", "damage_attestation"],
+        recommendation: "Adopt wip_provenance + independent_arbitration modules: Repository stores WIP hashes as tamper-proof delivery evidence; Arbitration (independent Permission) resolves false claims against on-chain proof.",
+    },
+    {
+        scenario: "supplier_may_not_deliver",
+        conflict: "Supplier incentive: accept sub-order payment terms then under-deliver, leaving the merchant liable to the end customer. Multi-party opacity hides the failure point.",
+        userProtection: {
+            mechanism: "Supplier visibility — Demand + sub-order flow with multi-tier Allocation; each tier paid only on its own verified delivery",
+            object: "Demand + Allocation (multi-tier)",
+            guard: "per-tier release guard",
+        },
+        merchantConstraint: {
+            requiredProof: "sub-delivery proof per Allocation tier",
+        },
+        evaluationMetric: "supplier_visibility",
+        mitigationSignals: [
+            ["module:supplier_collaboration"],
+            ["module:multi_tier_allocation"],
+        ],
+        mitigatingModules: ["supplier_collaboration", "multi_tier_allocation"],
+        recommendation: "Adopt supplier_collaboration module: publish Demand referencing the main Service, split Allocation across tiers so each supplier is paid only for verified sub-delivery.",
+    },
+];
+function evalSignal(token, graph, intent) {
+    const [kind, value] = token.split(":", 2);
+    switch (kind) {
+        case "node":
+            return graph.nodes.some((n) => n.id === value);
+        case "edge":
+            return graph.edges.some((e) => e.relation === value);
+        case "module":
+            return graph.adoptedModules.includes(value);
+        case "type":
+            return graph.nodes.some((n) => n.type === value);
+        case "trust": {
+            const v = intent.trust;
+            return v[value] === true || (typeof v[value] === "string" && v[value] !== "none");
+        }
+        default:
+            return false;
+    }
+}
+export function checkGameTheoryConstraints(graph, intent) {
+    const results = [];
+    for (const c of GAME_THEORY_CONSTRAINTS) {
+        let matched = null;
+        let bestPartial = [];
+        let bestPartialScore = -1;
+        for (const group of c.mitigationSignals) {
+            const hits = group.filter((s) => evalSignal(s, graph, intent));
+            if (hits.length === group.length) {
+                matched = group;
+                break;
+            }
+            const score = hits.length / group.length;
+            if (hits.length > 0 && score > bestPartialScore) {
+                bestPartialScore = score;
+                bestPartial = hits;
+            }
+        }
+        results.push({
+            scenario: c.scenario,
+            conflict: c.conflict,
+            covered: matched !== null,
+            matchedSignals: matched ?? [],
+            partialSignals: matched ? [] : bestPartial,
+            userProtection: `${c.userProtection.mechanism} (${c.userProtection.object}${c.userProtection.guard ? `, guard: ${c.userProtection.guard}` : ""})`,
+            evaluationMetric: c.evaluationMetric,
+            recommendation: matched ? undefined : c.recommendation,
+        });
+    }
+    const covered = results.filter((r) => r.covered);
+    const exposed = results.filter((r) => !r.covered);
+    const wowAlignments = [];
+    if (graph.edges.some((e) => e.relation === "has_order_allocators")) {
+        wowAlignments.push("Milestone escrow: funds locked in Order, released per verified milestone — merchant paid for delivery, user pays for value");
+    }
+    if (graph.adoptedModules.includes("accept_timeout_protection")) {
+        wowAlignments.push("Accept timeout: customer silence past N days = implicit acceptance — merchant protected from payment stalling");
+    }
+    if (graph.nodes.some((n) => n.id === "main_repository")) {
+        wowAlignments.push("WIP provenance: delivery hash on-chain — false claims verifiable against tamper-proof evidence");
+    }
+    if (graph.nodes.some((n) => n.id === "main_arbitration")) {
+        wowAlignments.push("Micro-arbitration: Guard-weighted voting with independent Permission — low-cost dispute resolution without platform fees");
+    }
+    if (graph.adoptedModules.includes("reputation_on_chain")) {
+        wowAlignments.push("On-chain reputation: both sides' behavior permanently recorded — future transactions price the risk");
+    }
+    return {
+        results,
+        coveredCount: covered.length,
+        totalCount: results.length,
+        exposedScenarios: exposed.map((r) => r.scenario),
+        wowAlignments,
+        summary: exposed.length === 0
+            ? `All ${results.length} adversarial scenarios have on-chain mitigations.`
+            : `${exposed.length}/${results.length} adversarial scenarios EXPOSED: ${exposed.map((r) => r.scenario).join(", ")}. Apply the recommendations to align incentives.`,
+    };
+}

package/dist/project/graph-builder.js

@@ -259,6 +259,7 @@ const EXPECTED_RELATIONSHIPS = new Map([
     ["Demand", [
             { targetType: "Guard", fieldName: "guard", relationshipType: "validate" },
             { targetType: "Reward", fieldName: "rewards", relationshipType: "trigger" },
+            { targetType: "Permission", fieldName: "permission", relationshipType: "validate", single: true },
             { targetType: "Contact", fieldName: "um", relationshipType: "bind", single: true },
         ]],
     ["Treasury", [

package/dist/project/handlers.d.ts

@@ -30,6 +30,7 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
     action: "create_project";
     project: import("@wowok/wowok").Project;
     blueprint: {
+        industry_mismatch_hint?: string | undefined;
         objects_count: number;
         edges_count: number;
         industry_source: string;
@@ -37,6 +38,15 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
         steps_count: number;
         scenarios_count: number;
         key_risk: string | undefined;
+        intent_inference: {
+            traits: import("../knowledge/industry-registry.js").IndustryTraits;
+            confidence: number;
+            matched_keywords: string[];
+            top_matches: {
+                industry: string;
+                similarity: number;
+            }[];
+        };
     };
     recommended_creation_order: {
         step: number;
@@ -47,6 +57,7 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
     blueprint_warning?: undefined;
     blueprint_skipped?: undefined;
     hint?: undefined;
+    recommended_industries?: undefined;
 } | {
     action: "create_project";
     project: import("@wowok/wowok").Project;
@@ -60,6 +71,7 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
     blueprint?: undefined;
     blueprint_skipped?: undefined;
     hint?: undefined;
+    recommended_industries?: undefined;
 } | {
     action: "create_project";
     project: import("@wowok/wowok").Project;
@@ -73,6 +85,31 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
     }[];
     blueprint?: undefined;
     blueprint_warning?: undefined;
+    recommended_industries?: undefined;
+} | {
+    action: "create_project";
+    project: import("@wowok/wowok").Project;
+    recommended_creation_order: {
+        step: number;
+        object: string;
+        reason: string;
+        required: boolean;
+    }[];
+    recommended_industries: {
+        industry: string;
+        similarity: number;
+        matched_traits: string[];
+        reference_examples: {
+            file: string;
+            title: string;
+            operation_type: string;
+            verified: boolean;
+        }[];
+    }[];
+    hint: string;
+    blueprint?: undefined;
+    blueprint_warning?: undefined;
+    blueprint_skipped?: undefined;
 } | {
     action: "create_project";
     project: import("@wowok/wowok").Project;
@@ -86,6 +123,7 @@ export declare function handleCreateProject(v: ProjectInput): Promise<{
     blueprint_warning?: undefined;
     blueprint_skipped?: undefined;
     hint?: undefined;
+    recommended_industries?: undefined;
 }>;
 export declare function handleCreateProjectFromOnchain(v: ProjectInput): Promise<{
     action: "create_project_from_onchain";

package/dist/project/handlers.js

@@ -1,10 +1,12 @@
-import { LocalProject, LocalMark, query_objects, query_table, } from "@wowok/wowok";
+import { LocalProject, LocalMark, query_objects, } from "@wowok/wowok";
+import { fetchMachineNodes } from "./machine-nodes.js";
 import { GraphBuilder } from "./graph-builder.js";
 import { SemanticAssembler } from "./semantic-assembler.js";
 import { runEvaluation, compareProjects, } from "./evaluation.js";
 import { TaskTracker } from "./task-tracker.js";
 import { renderGuardMermaid, renderGuardTreeIndented, renderGuardAscii, renderGuardMarkmap, } from "../knowledge/guard-render.js";
 import { renderMachineMermaid, renderMachineTreeIndented, renderMachineAscii, renderMachineMarkmap, } from "../knowledge/machine-render.js";
+import { inferTraitsFromDescription, findSimilarIndustries, } from "../knowledge/industry-generalizer.js";
 import { isObjectOfType } from "../schema/utils/object-type-utils.js";
 const localProject = LocalProject.Instance();
 function requireField(value, name) {
@@ -169,7 +171,28 @@ export async function handleCreateProject(v) {
                 business_intent: v.project_description ?? name,
                 industry,
             };
-            const blueprint = registry.applyTemplate(industry, context.business_intent, context);
+            const blueprint = await registry.applyTemplate(industry, context.business_intent, context);
+            const intentInference = inferTraitsFromDescription(context.business_intent);
+            const industryMatches = findSimilarIndustries(intentInference.traits, 3);
+            const intentInferenceSummary = {
+                traits: intentInference.traits,
+                confidence: intentInference.confidence,
+                matched_keywords: intentInference.matched_keywords,
+                top_matches: industryMatches.map((m) => ({
+                    industry: m.industry,
+                    similarity: m.similarity,
+                })),
+            };
+            const topMatch = industryMatches[0];
+            const industryMismatchHint = topMatch &&
+                !industryMatches.some((m) => m.industry === industry) &&
+                intentInference.confidence >= 0.3 &&
+                topMatch.similarity >= 0.6
+                ? `Intent inference suggests industry '${topMatch.industry}' ` +
+                    `(similarity ${(topMatch.similarity * 100).toFixed(0)}%) may fit the description ` +
+                    `better than the chosen '${industry}'. Call action='recommend_industry' for the full ` +
+                    `recommendation chain, or ignore this hint if '${industry}' was chosen intentionally.`
+                : undefined;
             const draftObjects = [];
             for (const obj of blueprint.objects) {
                 const projectObj = await localProject.addObject(project.id, {
@@ -203,6 +226,20 @@ export async function handleCreateProject(v) {
                 },
             }));
             await localProject.saveGraphEdges(project.id, graphEdges);
+            try {
+                await localProject.saveDocument(project.id, context.network, JSON.stringify({
+                    applied_template: blueprint.applied_template,
+                    industry_source: blueprint.industry_source,
+                    steps: blueprint.steps,
+                    scenarios: blueprint.scenarios ?? [],
+                    validation: blueprint.validation,
+                    intent_inference: intentInferenceSummary,
+                    generated_at: new Date().toISOString(),
+                }, null, 2), "blueprint");
+            }
+            catch (docErr) {
+                console.warn(`[create_project] Failed to persist blueprint document: ${docErr.message}`);
+            }
             return {
                 action: "create_project",
                 project,
@@ -214,6 +251,8 @@ export async function handleCreateProject(v) {
                     steps_count: blueprint.steps.length,
                     scenarios_count: blueprint.scenarios?.length ?? 0,
                     key_risk: registry.getMode(industry)?.key_risk,
+                    intent_inference: intentInferenceSummary,
+                    ...(industryMismatchHint ? { industry_mismatch_hint: industryMismatchHint } : {}),
                 },
                 recommended_creation_order: getRecommendedCreationOrder(industry),
             };
@@ -236,6 +275,29 @@ export async function handleCreateProject(v) {
             recommended_creation_order: getRecommendedCreationOrder(industry),
         };
     }
+    if (!industry) {
+        const intentText = (v.project_description ?? name).trim();
+        if (intentText) {
+            try {
+                const { handleRecommendIndustry } = await import("./mode-actions.js");
+                const rec = handleRecommendIndustry({ intent: intentText });
+                if (rec.recommendations.length > 0) {
+                    return {
+                        action: "create_project",
+                        project,
+                        recommended_creation_order: getRecommendedCreationOrder(industry),
+                        recommended_industries: rec.recommendations,
+                        hint: "No industry specified. Based on your description, top match is '" +
+                            rec.recommendations[0].industry + "'. To get a ready-made blueprint " +
+                            "(~10 draft objects + graph edges), recreate with project_industry set — " +
+                            "or continue from scratch with add_object.",
+                    };
+                }
+            }
+            catch {
+            }
+        }
+    }
     return {
         action: "create_project",
         project,
@@ -1247,39 +1309,7 @@ export async function handleGetMachineGraph(v) {
     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);
-                    }
-                }
-            }
-        }
+        rawNodes = await fetchMachineNodes(machineAddress, network);
     }
     catch (e) {
         throw new Error(`Failed to query Machine nodes on ${network}: ${e instanceof Error ? e.message : String(e)}`);

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;
+}