@wowok/agent-mcp 2.6.1 → 2.6.4

package/dist/project/game-theory.d.ts

@@ -0,0 +1,43 @@
+import type { SemanticObjectGraph } from "./semantic-graph.js";
+import type { BusinessIntent } from "./intent-analyzer.js";
+import type { BusinessModuleId } from "../extensions/business-modules.js";
+export type GameScenario = "merchant_may_deliver_late" | "merchant_may_abandon" | "customer_may_deny_acceptance" | "customer_may_false_claim" | "supplier_may_not_deliver";
+export interface GameTheoryConstraint {
+    scenario: GameScenario;
+    conflict: string;
+    userProtection: {
+        mechanism: string;
+        object: string;
+        guard?: string;
+    };
+    merchantConstraint: {
+        requiredDeposit?: boolean;
+        requiredArbitration?: boolean;
+        requiredProof?: string;
+        timeoutPenalty?: string;
+    };
+    evaluationMetric: string;
+    mitigationSignals: string[][];
+    mitigatingModules: BusinessModuleId[];
+    recommendation: string;
+}
+export interface GameTheoryCheckResult {
+    scenario: GameScenario;
+    conflict: string;
+    covered: boolean;
+    matchedSignals: string[];
+    partialSignals: string[];
+    userProtection: string;
+    evaluationMetric: string;
+    recommendation?: string;
+}
+export interface GameTheoryReport {
+    results: GameTheoryCheckResult[];
+    coveredCount: number;
+    totalCount: number;
+    exposedScenarios: GameScenario[];
+    wowAlignments: string[];
+    summary: string;
+}
+export declare const GAME_THEORY_CONSTRAINTS: GameTheoryConstraint[];
+export declare function checkGameTheoryConstraints(graph: SemanticObjectGraph, intent: BusinessIntent): GameTheoryReport;

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

@@ -9,7 +9,12 @@ function shortTypeName(objectType) {
 }
 function extractAddressFields(obj) {
     const refs = [];
-    const objType = obj.type;
+    const rawType = obj.type;
+    let objType = rawType;
+    if (rawType && rawType.includes("::")) {
+        const parts = rawType.split("::");
+        objType = parts[parts.length - 1];
+    }
     const isAddress = (v) => typeof v === "string" && v.startsWith("0x") && v.length >= 10;
     const addRef = (addr, field, refType) => {
         if (isAddress(addr) && addr !== "0x0" && addr !== obj.object) {
@@ -254,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

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import { type ProjectObject, type EvaluationType } from "@wowok/wowok";
+import { type ProjectObject, type ObjectRole, type EvaluationType } from "@wowok/wowok";
 import type { ProjectOperationInputSchema } from "../schema/project/index.js";
 type ProjectInput = z.infer<typeof ProjectOperationInputSchema>;
 export declare function handleListProjects(v: ProjectInput): Promise<{
@@ -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";
@@ -100,14 +138,31 @@ export declare function handleUpdateProject(v: ProjectInput): Promise<{
 export declare function handleGetProjectDetail(v: ProjectInput): Promise<{
     action: "get_project_detail";
     project: import("@wowok/wowok").Project;
-    objects: ProjectObject[];
+    objects: {
+        isDraft: boolean;
+        id: string;
+        projectId: string;
+        objectAddress: string;
+        objectType: string | null;
+        objectName: string | null;
+        role: ObjectRole;
+        tags: string[] | null;
+        addedAt: number;
+        metadata: Record<string, unknown> | null;
+    }[];
+    objectCount: number;
+    onchainCount: number;
+    draftCount: number;
     objectGroups: {
         core: ProjectObject[];
         dependency: ProjectObject[];
         reference: ProjectObject[];
         other: ProjectObject[];
+        draft: ProjectObject[];
         stats: {
             total: number;
+            onchain_count: number;
+            draft_count: number;
             core_count: number;
             dependency_count: number;
             reference_count: number;
@@ -212,6 +267,8 @@ export declare function handleEvaluateProject(v: ProjectInput): Promise<{
     needsLlm: boolean;
     llmPrompt: string | undefined;
     evaluationId: string;
+    refreshWarning: string | undefined;
+    graphFallbackWarning: string | undefined;
 }>;
 export declare function handleSaveEvaluation(v: ProjectInput): Promise<{
     action: "save_evaluation";
@@ -248,6 +305,67 @@ export declare function handleCloneProjectToNetwork(v: ProjectInput): Promise<{
     message: string;
     next_steps: string;
 }>;
+export declare function handleMigrateToMainnet(v: ProjectInput): Promise<{
+    action: "migrate_to_mainnet";
+    migration_status: string;
+    source_project: {
+        prefix: string;
+        network: string;
+        preserved: boolean;
+    };
+    target_project: {
+        prefix: string;
+        project_id: string;
+        network: string;
+        cloned_objects_count: number;
+    };
+    key_principle: string;
+    migration_plan: ({
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        result: string;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+        names_to_register?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        deployment_plan: {
+            order: number;
+            object_type: string;
+            object_name: string;
+            operation_type: string;
+            localmark_name: string;
+            note: string;
+        }[];
+        critical_note: string;
+        result?: undefined;
+        names_to_register?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        names_to_register: string[];
+        result?: undefined;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+    } | {
+        step: number;
+        status: string;
+        action: string;
+        description: string;
+        result?: undefined;
+        deployment_plan?: undefined;
+        critical_note?: undefined;
+        names_to_register?: undefined;
+    })[];
+    summary: string;
+}>;
 export declare function handleGetObjectDiff(v: ProjectInput): Promise<{
     action: "get_object_diff";
     address: string;
@@ -284,6 +402,23 @@ export declare function handleGetMachineGraph(v: ProjectInput): Promise<{
     }[];
     published: boolean | null;
     paused: boolean | null;
+    mermaid: string;
+    tree_outline: string;
+    ascii_art: string;
+    markmap: string;
+}>;
+export declare function handleGetGuardGraph(v: ProjectInput): Promise<{
+    action: "get_guard_graph";
+    guardAddress: string;
+    guardName: string | null;
+    root: any;
+    table: any[];
+    rely: any;
+    immutable: any;
+    mermaid: string;
+    tree_outline: string;
+    ascii_art: string;
+    markmap: string;
 }>;
 export declare function handlePreEvaluateCheck(v: ProjectInput): Promise<{
     action: "pre_evaluate_check";