@wowok/agent-mcp 2.6.3 → 2.6.4

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

package/dist/project/mode-actions.d.ts

@@ -0,0 +1,199 @@
+import { type MetricType, type MetricScale, type ConstraintRule, type ConstraintSeverity, type ConstraintViolationAction } from "../extensions/index.js";
+export interface RecommendIndustryInput {
+    intent?: string;
+    project_description?: string;
+    project_name?: string;
+}
+export declare function handleRecommendIndustry(v: RecommendIndustryInput): {
+    action: "recommend_industry";
+    intent: string;
+    inferred_traits: import("../knowledge/industry-registry.js").IndustryTraits;
+    inference_confidence: number;
+    matched_keywords: string[];
+    recommendations: {
+        industry: string;
+        similarity: number;
+        matched_traits: string[];
+        reference_examples: {
+            file: string;
+            title: string;
+            operation_type: string;
+            verified: boolean;
+        }[];
+    }[];
+    hint: string;
+};
+export declare function handleListModes(): Promise<{
+    action: "list_modes";
+    builtin_modes: {
+        name: string;
+        display_name: string;
+        version: string;
+        key_risk: string;
+        machine_nodes: string[];
+        similar_industries: string[];
+    }[];
+    user_modes: {
+        name: string;
+        display_name: string;
+        version: string;
+        derived_from: string | null;
+        key_risk: string;
+        machine_nodes: string[];
+        evolution_history: {
+            version: string;
+            changed_at: number;
+            changes: string[];
+        }[];
+    }[];
+    owner: string;
+    hint: string;
+}>;
+export interface DeriveUserModeInput {
+    mode_source?: string;
+    mode_name?: string;
+    mode_display_name?: string;
+    mode_changes?: Record<string, unknown>;
+}
+export declare function handleDeriveUserMode(v: DeriveUserModeInput): Promise<{
+    action: "derive_user_mode";
+    mode: {
+        name: string;
+        display_name: string;
+        version: string;
+        derived_from: string | null;
+        owner: string;
+        key_risk: string;
+        machine_nodes: string[];
+        evolution_history: {
+            version: string;
+            changed_at: number;
+            changes: string[];
+        }[];
+    };
+    hint: string;
+}>;
+export interface EvolveUserModeInput {
+    mode_name?: string;
+    mode_changes?: Record<string, unknown>;
+    mode_change_description?: string;
+    mode_bump_version?: boolean;
+}
+export declare function handleEvolveUserMode(v: EvolveUserModeInput): Promise<{
+    action: "evolve_user_mode";
+    mode: {
+        name: string;
+        display_name: string;
+        version: string;
+        derived_from: string | null;
+        owner: string;
+        key_risk: string;
+        machine_nodes: string[];
+        evolution_history: {
+            version: string;
+            changed_at: number;
+            changes: string[];
+        }[];
+    };
+    hint: string;
+}>;
+export interface RegisterUserModeInput {
+    mode_name?: string;
+    mode_display_name?: string;
+    mode_changes?: Record<string, unknown>;
+}
+export declare function handleRegisterUserMode(v: RegisterUserModeInput): Promise<{
+    action: "register_user_mode";
+    mode: {
+        name: string;
+        display_name: string;
+        version: string;
+        derived_from: string | null;
+        owner: string;
+        key_risk: string;
+        machine_nodes: string[];
+        evolution_history: {
+            version: string;
+            changed_at: number;
+            changes: string[];
+        }[];
+    };
+    hint: string;
+}>;
+export declare function handleUnregisterUserMode(v: {
+    mode_name?: string;
+}): Promise<{
+    action: "unregister_user_mode";
+    removed: true;
+    mode_name: string;
+}>;
+export interface RegisterCustomMetricInput {
+    metric_id?: string;
+    metric_display_name?: string;
+    metric_description?: string;
+    metric_type?: MetricType;
+    metric_scale?: MetricScale;
+    metric_weight?: number;
+}
+export declare function handleRegisterCustomMetric(v: RegisterCustomMetricInput): {
+    action: "register_custom_metric";
+    metric: {
+        metric_id: string;
+        display_name: string;
+        description: string;
+        type: "risk" | "benefit";
+        scale: "level" | "numeric" | "percentage";
+        weight: number;
+        scope: string;
+        owner: string;
+    };
+    hint: string;
+};
+export interface RegisterCustomConstraintInput {
+    constraint_id?: string;
+    constraint_display_name?: string;
+    constraint_description?: string;
+    constraint_rule?: ConstraintRule;
+    constraint_severity?: ConstraintSeverity;
+    constraint_on_violation?: ConstraintViolationAction;
+}
+export declare function handleRegisterCustomConstraint(v: RegisterCustomConstraintInput): {
+    action: "register_custom_constraint";
+    constraint: {
+        constraint_id: string;
+        display_name: string;
+        description: string;
+        rule: ConstraintRule;
+        severity: ConstraintSeverity;
+        on_violation: ConstraintViolationAction;
+        scope: string;
+        owner: string;
+    };
+    hint: string;
+};
+export interface ListMetricsConstraintsInput {
+    metric_type_filter?: MetricType;
+    scope_filter?: "builtin" | "custom";
+}
+export declare function handleListMetricsConstraints(v: ListMetricsConstraintsInput): {
+    action: "list_metrics_constraints";
+    metrics: {
+        metric_id: string;
+        display_name: string;
+        description: string;
+        type: MetricType;
+        scale: MetricScale;
+        weight: number | undefined;
+        scope: "custom" | "builtin";
+    }[];
+    constraints: {
+        constraint_id: string;
+        display_name: string;
+        description: string;
+        rule: ConstraintRule;
+        severity: ConstraintSeverity;
+        on_violation: ConstraintViolationAction;
+        scope: "custom" | "builtin";
+    }[];
+    hint: string;
+};