@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/service-puzzle.d.ts

@@ -0,0 +1,158 @@
+import { type ServicePermissionEntry } from "./service-ledger.js";
+export interface ServiceIntentPuzzle {
+    action: "create" | "modify" | "publish" | "pause" | "order" | "compensate" | "query";
+    business_scenario: "retail" | "service" | "digital_goods" | "rental" | "freelance" | "travel_package" | "subscription" | "general";
+    lifecycle_phase: "draft" | "published" | "paused" | "deprecated";
+    primary_goal: string;
+    failure_conditions: string[];
+}
+export interface ServiceBindingPuzzle {
+    coin_type: string;
+    permission: string;
+    owner: string;
+    admins: string[];
+    um?: string | null;
+    machine?: string | null;
+    buy_guard?: string | null;
+    order_allocators?: object | null;
+    arbitrations: string[];
+    rewards: string[];
+    repositories: string[];
+    compensation_fund_balance: string;
+    setting_lock_duration: string;
+}
+export interface ServicePermissionAllocatorPuzzle {
+    permission_indexes_used: ServicePermissionEntry[];
+    allocators_configured: boolean;
+    allocators_summary?: string;
+    guards_bound: {
+        kind: "buy_guard";
+        address: string;
+    }[];
+    treasury_addresses_referenced: string[];
+}
+export interface ServiceGuardProtectionPuzzle {
+    buy_guard_set: boolean;
+    buy_guard_address?: string;
+    buy_guard_post_publish_mutable: boolean;
+    allocators_guards_count: number;
+    repository_guards_count: number;
+}
+export interface ServiceDisputeHandlingPuzzle {
+    arbitrations_count: number;
+    arbitrations_addresses: string[];
+    compensation_fund_configured: boolean;
+    compensation_fund_balance: string;
+    setting_lock_duration_ms: string;
+    setting_lock_duration_can_only_increase: boolean;
+    publish_prerequisites_met: boolean;
+    publish_blockers: string[];
+}
+export interface ServiceConstraintChecklist {
+    F_S_01_description_length_le_4000: boolean;
+    F_S_02_sales_count_le_50: boolean;
+    F_S_03_repositories_count_le_100: boolean;
+    F_S_04_arbitrations_count_le_20: boolean;
+    F_S_05_rewards_count_le_20: boolean;
+    F_S_06_customer_required_count_le_10: boolean;
+    F_S_07_customer_required_each_le_20: boolean;
+    F_S_08_discount_once_le_1000: boolean;
+    F_S_09_discount_receivers_le_1000: boolean;
+    F_S_10_discount_total_le_20000: boolean;
+    F_S_11_wip_url_length_le_1024: boolean;
+    F_S_12_wip_hash_length_le_64: boolean;
+    F_S_13_wip_hash_not_empty: boolean;
+    F_S_14_quote_stock_sufficient: boolean;
+    F_S_15_quote_sale_not_suspended: boolean;
+    F_S_16_buy_requires_published: boolean;
+    F_S_17_buy_requires_not_paused: boolean;
+    F_S_18_publish_requires_order_allocators: boolean;
+    F_S_19_publish_compensation_fund_requires_arbitrations: boolean;
+    F_S_20_machine_immutable_post_publish: boolean;
+    F_S_21_arbitrations_immutable_post_publish: boolean;
+    F_S_22_order_allocators_immutable_post_publish: boolean;
+    F_S_23_bPublished_irreversible: boolean;
+    F_S_24_setting_lock_duration_only_increases: boolean;
+    F_S_25_compensation_fund_withdraw_locked_by_duration: boolean;
+    F_S_26_compensation_fund_withdraw_requires_paused: boolean;
+    F_S_27_quote_deducts_stock_side_effect: boolean;
+    F_S_28_order_service_must_match: boolean;
+    F_S_29_order_one_to_one_with_service: boolean;
+    F_S_30_permission_indexes_300_to_320: boolean;
+}
+export type ServicePuzzleDimension = "A" | "B" | "C" | "D" | "E" | "F";
+export interface ServicePuzzle {
+    intent?: ServiceIntentPuzzle;
+    binding?: ServiceBindingPuzzle;
+    permission_allocator?: ServicePermissionAllocatorPuzzle;
+    guard_protection?: ServiceGuardProtectionPuzzle;
+    dispute_handling?: ServiceDisputeHandlingPuzzle;
+    constraints?: ServiceConstraintChecklist;
+}
+export interface ServicePuzzleCompleteness {
+    dimensions: ServicePuzzleDimension[];
+    missing: ServicePuzzleDimension[];
+    missing_details: {
+        dimension: ServicePuzzleDimension;
+        reason: string;
+    }[];
+    complete: boolean;
+    next_step: string;
+}
+export interface ServiceOrderFlowPuzzle {
+    stage_1_pre_check: {
+        bPublished: boolean;
+        bPaused: boolean;
+        buy_guard?: string;
+        ready: boolean;
+    };
+    stage_2_wip_verify: {
+        items_count: number;
+        wip_verified: boolean;
+        wip_hash_mismatches: string[];
+    };
+    stage_3_quote: {
+        items_quoted: number;
+        stock_sufficient: boolean;
+        discount_applied: boolean;
+        total_pay: string;
+    };
+    stage_4_create_order: {
+        order_created: boolean;
+        passport_used: boolean;
+    };
+    stage_5_create_allocation: {
+        allocation_created: boolean;
+        allocators_configured: boolean;
+    };
+    stage_6_create_progress: {
+        progress_created: boolean;
+        machine_bound: boolean;
+    };
+    stage_7_post_actions: {
+        agents_set: boolean;
+        required_info_set: boolean;
+        transfer_set: boolean;
+    };
+    stage_8_return_result: {
+        order_address?: string;
+        allocation_address?: string;
+        progress_address?: string;
+    };
+}
+export declare function initPuzzleFromIntent(intent: Partial<ServiceIntentPuzzle>): ServicePuzzle;
+export declare function checkPuzzleCompleteness(puzzle: ServicePuzzle): ServicePuzzleCompleteness;
+export interface ServiceConstraintViolation {
+    constraint_id: string;
+    severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+    message: string;
+    current_value?: string | number;
+    limit?: string | number;
+}
+export declare function validateConstraints(puzzle: ServicePuzzle): ServiceConstraintViolation[];
+export declare function generateConfirmationText(puzzle: ServicePuzzle): string;
+export declare function initOrderFlowPuzzle(buy_items_count: number, machine_bound: boolean): ServiceOrderFlowPuzzle;
+export declare function checkOrderFlowCompleteness(flow: ServiceOrderFlowPuzzle): {
+    complete: boolean;
+    blockers: string[];
+};

package/dist/knowledge/service-puzzle.js

@@ -0,0 +1,236 @@
+import { MAX_SALE_COUNT, MAX_REPOSITORY_COUNT, MAX_ARBITRATION_COUNT, MAX_DISCOUNT_COUNT_ONCE, MAX_DISCOUNT_TOTAL_COUNT, MAX_REQUIRED_INFO_SIZE, MAX_WIP_LENGTH, MAX_WIP_HASH_LENGTH, } from "@wowok/wowok";
+export function initPuzzleFromIntent(intent) {
+    const puzzle = {};
+    if (intent.action || intent.primary_goal) {
+        puzzle.intent = {
+            action: intent.action ?? "create",
+            business_scenario: intent.business_scenario ?? "general",
+            lifecycle_phase: intent.lifecycle_phase ?? "draft",
+            primary_goal: intent.primary_goal ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        };
+    }
+    puzzle.constraints = {
+        F_S_01_description_length_le_4000: true,
+        F_S_02_sales_count_le_50: true,
+        F_S_03_repositories_count_le_100: true,
+        F_S_04_arbitrations_count_le_20: true,
+        F_S_05_rewards_count_le_20: true,
+        F_S_06_customer_required_count_le_10: true,
+        F_S_07_customer_required_each_le_20: true,
+        F_S_08_discount_once_le_1000: true,
+        F_S_09_discount_receivers_le_1000: true,
+        F_S_10_discount_total_le_20000: true,
+        F_S_11_wip_url_length_le_1024: true,
+        F_S_12_wip_hash_length_le_64: true,
+        F_S_13_wip_hash_not_empty: true,
+        F_S_14_quote_stock_sufficient: true,
+        F_S_15_quote_sale_not_suspended: true,
+        F_S_16_buy_requires_published: true,
+        F_S_17_buy_requires_not_paused: true,
+        F_S_18_publish_requires_order_allocators: true,
+        F_S_19_publish_compensation_fund_requires_arbitrations: true,
+        F_S_20_machine_immutable_post_publish: true,
+        F_S_21_arbitrations_immutable_post_publish: true,
+        F_S_22_order_allocators_immutable_post_publish: true,
+        F_S_23_bPublished_irreversible: true,
+        F_S_24_setting_lock_duration_only_increases: true,
+        F_S_25_compensation_fund_withdraw_locked_by_duration: true,
+        F_S_26_compensation_fund_withdraw_requires_paused: true,
+        F_S_27_quote_deducts_stock_side_effect: true,
+        F_S_28_order_service_must_match: true,
+        F_S_29_order_one_to_one_with_service: true,
+        F_S_30_permission_indexes_300_to_320: true,
+    };
+    return puzzle;
+}
+export function checkPuzzleCompleteness(puzzle) {
+    const missing = [];
+    const missing_details = [];
+    if (!puzzle.intent) {
+        missing.push("A");
+        missing_details.push({ dimension: "A", reason: "Intent not specified (action + primary_goal)" });
+    }
+    else if (!puzzle.intent.primary_goal) {
+        missing.push("A");
+        missing_details.push({ dimension: "A", reason: "primary_goal is empty" });
+    }
+    if (!puzzle.binding) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "Binding not specified (coin_type + permission + owner)" });
+    }
+    else if (!puzzle.binding.coin_type || !puzzle.binding.permission || !puzzle.binding.owner) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "coin_type / permission / owner missing" });
+    }
+    if (!puzzle.permission_allocator && puzzle.intent?.action === "create") {
+        missing.push("C");
+        missing_details.push({ dimension: "C", reason: "Permission/allocator config not specified" });
+    }
+    if (!puzzle.guard_protection) {
+        missing.push("D");
+        missing_details.push({ dimension: "D", reason: "Guard protection not enumerated" });
+    }
+    if (!puzzle.dispute_handling && puzzle.intent?.action === "publish") {
+        missing.push("E");
+        missing_details.push({ dimension: "E", reason: "Dispute handling not configured (needed for publish)" });
+    }
+    if (!puzzle.constraints) {
+        missing.push("F");
+        missing_details.push({ dimension: "F", reason: "Constraints not checked" });
+    }
+    return {
+        dimensions: ["A", "B", "C", "D", "E", "F"],
+        missing,
+        missing_details,
+        complete: missing.length === 0,
+        next_step: missing.length === 0
+            ? "Puzzle complete — ready for confirmation text generation"
+            : `Next: complete dimension ${missing[0]} — ${missing_details[0].reason}`,
+    };
+}
+export function validateConstraints(puzzle) {
+    const violations = [];
+    if (!puzzle.constraints)
+        return violations;
+    const c = puzzle.constraints;
+    const checks = [
+        [!c.F_S_02_sales_count_le_50, "F-S-02", "CRITICAL", "sales count", MAX_SALE_COUNT],
+        [!c.F_S_03_repositories_count_le_100, "F-S-03", "HIGH", "repositories count", MAX_REPOSITORY_COUNT],
+        [!c.F_S_04_arbitrations_count_le_20, "F-S-04", "HIGH", "arbitrations count", MAX_ARBITRATION_COUNT],
+        [!c.F_S_05_rewards_count_le_20, "F-S-05", "MEDIUM", "rewards count", 20],
+        [!c.F_S_06_customer_required_count_le_10, "F-S-06", "MEDIUM", "customer_required count", 10],
+        [!c.F_S_07_customer_required_each_le_20, "F-S-07", "LOW", "customer_required item length", MAX_REQUIRED_INFO_SIZE],
+        [!c.F_S_08_discount_once_le_1000, "F-S-08", "MEDIUM", "discount count (once)", MAX_DISCOUNT_COUNT_ONCE],
+        [!c.F_S_10_discount_total_le_20000, "F-S-10", "MEDIUM", "discount total count", MAX_DISCOUNT_TOTAL_COUNT],
+        [!c.F_S_11_wip_url_length_le_1024, "F-S-11", "HIGH", "wip URL length", MAX_WIP_LENGTH],
+        [!c.F_S_12_wip_hash_length_le_64, "F-S-12", "HIGH", "wip_hash length", MAX_WIP_HASH_LENGTH],
+        [!c.F_S_13_wip_hash_not_empty, "F-S-13", "CRITICAL", "wip_hash empty", undefined],
+        [!c.F_S_18_publish_requires_order_allocators, "F-S-18", "CRITICAL", "publish without order_allocators", undefined],
+        [!c.F_S_19_publish_compensation_fund_requires_arbitrations, "F-S-19", "CRITICAL", "publish with compensation_fund > 0 but no arbitrations", undefined],
+    ];
+    for (const [failed, id, sev, msg, limit] of checks) {
+        if (failed) {
+            violations.push({
+                constraint_id: id,
+                severity: sev,
+                message: `${msg} violates ${id}`,
+                limit,
+            });
+        }
+    }
+    return violations;
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [];
+    lines.push("═══ Service Confirmation ═══");
+    lines.push("");
+    if (puzzle.intent) {
+        lines.push(`Action: ${puzzle.intent.action}`);
+        lines.push(`Scenario: ${puzzle.intent.business_scenario}`);
+        lines.push(`Lifecycle: ${puzzle.intent.lifecycle_phase}`);
+        lines.push(`Goal: ${puzzle.intent.primary_goal}`);
+        if (puzzle.intent.failure_conditions.length > 0) {
+            lines.push("Failure conditions:");
+            for (const fc of puzzle.intent.failure_conditions)
+                lines.push(`  - ${fc}`);
+        }
+        lines.push("");
+    }
+    if (puzzle.binding) {
+        lines.push("─ Binding ──────────────");
+        lines.push(`Coin type: ${puzzle.binding.coin_type}`);
+        lines.push(`Permission: ${puzzle.binding.permission}`);
+        lines.push(`Owner: ${puzzle.binding.owner}`);
+        lines.push(`Admins (${puzzle.binding.admins.length}): ${puzzle.binding.admins.join(", ")}`);
+        if (puzzle.binding.um !== undefined)
+            lines.push(`UM: ${puzzle.binding.um ?? "(none)"}`);
+        if (puzzle.binding.machine !== undefined)
+            lines.push(`Machine: ${puzzle.binding.machine ?? "(none)"} ${puzzle.intent?.lifecycle_phase === "published" ? "[LOCKED]" : ""}`);
+        if (puzzle.binding.buy_guard !== undefined)
+            lines.push(`Buy Guard: ${puzzle.binding.buy_guard ?? "(none)"} [mutable post-publish]`);
+        if (puzzle.binding.order_allocators !== undefined)
+            lines.push(`Order Allocators: ${puzzle.binding.order_allocators ? "configured" : "(none)"} ${puzzle.intent?.lifecycle_phase === "published" ? "[LOCKED]" : ""}`);
+        lines.push(`Arbitrations (${puzzle.binding.arbitrations.length}): ${puzzle.binding.arbitrations.join(", ")}`);
+        lines.push(`Rewards (${puzzle.binding.rewards.length})`);
+        lines.push(`Repositories (${puzzle.binding.repositories.length})`);
+        lines.push(`Compensation fund: ${puzzle.binding.compensation_fund_balance}`);
+        lines.push(`Setting lock duration: ${puzzle.binding.setting_lock_duration} ms`);
+        lines.push("");
+    }
+    if (puzzle.permission_allocator) {
+        lines.push("─ Permission / Allocators ──────────────");
+        lines.push(`Permission indexes used (${puzzle.permission_allocator.permission_indexes_used.length}):`);
+        for (const p of puzzle.permission_allocator.permission_indexes_used) {
+            lines.push(`  [${p.index}] ${p.name}: ${p.description}`);
+        }
+        lines.push(`Allocators configured: ${puzzle.permission_allocator.allocators_configured}`);
+        if (puzzle.permission_allocator.allocators_summary) {
+            lines.push(`Allocators summary: ${puzzle.permission_allocator.allocators_summary}`);
+        }
+        lines.push("");
+    }
+    if (puzzle.guard_protection) {
+        lines.push("─ Guard Protection ──────────────");
+        lines.push(`Buy guard set: ${puzzle.guard_protection.buy_guard_set}`);
+        if (puzzle.guard_protection.buy_guard_address) {
+            lines.push(`Buy guard: ${puzzle.guard_protection.buy_guard_address}`);
+        }
+        lines.push(`Buy guard post-publish mutable: ${puzzle.guard_protection.buy_guard_post_publish_mutable}`);
+        lines.push(`Allocators guards: ${puzzle.guard_protection.allocators_guards_count}`);
+        lines.push(`Repository guards: ${puzzle.guard_protection.repository_guards_count}`);
+        lines.push("");
+    }
+    if (puzzle.dispute_handling) {
+        lines.push("─ Dispute Handling ──────────────");
+        lines.push(`Arbitrations: ${puzzle.dispute_handling.arbitrations_count}`);
+        lines.push(`Compensation fund: ${puzzle.dispute_handling.compensation_fund_balance}`);
+        lines.push(`Setting lock duration: ${puzzle.dispute_handling.setting_lock_duration_ms} ms (only-increase: ${puzzle.dispute_handling.setting_lock_duration_can_only_increase})`);
+        lines.push(`Publish prerequisites met: ${puzzle.dispute_handling.publish_prerequisites_met}`);
+        if (puzzle.dispute_handling.publish_blockers.length > 0) {
+            lines.push(`Publish blockers:`);
+            for (const b of puzzle.dispute_handling.publish_blockers)
+                lines.push(`  - ${b}`);
+        }
+        lines.push("");
+    }
+    const violations = validateConstraints(puzzle);
+    if (violations.length > 0) {
+        lines.push("─ Constraint Violations ──────────────");
+        for (const v of violations)
+            lines.push(`  [${v.severity}] ${v.constraint_id}: ${v.message}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function initOrderFlowPuzzle(buy_items_count, machine_bound) {
+    return {
+        stage_1_pre_check: { bPublished: false, bPaused: false, ready: false },
+        stage_2_wip_verify: { items_count: buy_items_count, wip_verified: false, wip_hash_mismatches: [] },
+        stage_3_quote: { items_quoted: 0, stock_sufficient: false, discount_applied: false, total_pay: "0" },
+        stage_4_create_order: { order_created: false, passport_used: false },
+        stage_5_create_allocation: { allocation_created: false, allocators_configured: false },
+        stage_6_create_progress: { progress_created: false, machine_bound },
+        stage_7_post_actions: { agents_set: false, required_info_set: false, transfer_set: false },
+        stage_8_return_result: {},
+    };
+}
+export function checkOrderFlowCompleteness(flow) {
+    const blockers = [];
+    if (!flow.stage_1_pre_check.ready)
+        blockers.push("Stage 1 pre_check failed: bPublished && !bPaused required");
+    if (!flow.stage_2_wip_verify.wip_verified)
+        blockers.push("Stage 2 wip_verify failed: WIP hash mismatch");
+    if (flow.stage_2_wip_verify.wip_hash_mismatches.length > 0)
+        blockers.push(`Stage 2 mismatched items: ${flow.stage_2_wip_verify.wip_hash_mismatches.join(", ")}`);
+    if (!flow.stage_3_quote.stock_sufficient)
+        blockers.push("Stage 3 quote failed: stock insufficient");
+    if (!flow.stage_4_create_order.order_created)
+        blockers.push("Stage 4 create_order failed");
+    if (!flow.stage_5_create_allocation.allocation_created)
+        blockers.push("Stage 5 create_allocation failed (allocators not configured?)");
+    if (flow.stage_6_create_progress.machine_bound && !flow.stage_6_create_progress.progress_created) {
+        blockers.push("Stage 6 create_progress failed (machine bound but progress not created)");
+    }
+    return { complete: blockers.length === 0, blockers };
+}

package/dist/knowledge/service-risk.d.ts

@@ -0,0 +1,108 @@
+import { type ServiceScene } from "./service-ledger.js";
+export type ServiceRiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+export type ServiceRiskCategory = "structural" | "semantic" | "authority" | "lifecycle" | "cross_object";
+export interface ServiceRisk {
+    id: string;
+    level: ServiceRiskLevel;
+    category: ServiceRiskCategory;
+    title: string;
+    description: string;
+    affected_stakeholders: ServiceStakeholder[];
+    scenario: string;
+    mitigation: string;
+    evidence?: string;
+}
+export type ServiceStakeholder = "owner" | "customer" | "provider" | "arbitrator" | "system";
+export interface ServiceRiskRule {
+    id: string;
+    category: ServiceRiskCategory;
+    trigger: string;
+    check: (ctx: ServiceRiskCheckContext) => ServiceRisk | null;
+}
+export interface ServiceRiskCheckContext {
+    object?: string | null;
+    description?: string;
+    location?: string;
+    sales?: {
+        op: "add" | "set";
+        sales: Array<{
+            name: string;
+            wip: string;
+            wip_hash: string;
+        }>;
+    } | {
+        op: "remove";
+        sales_name: string[];
+    } | {
+        op: "clear";
+    };
+    repositories?: {
+        op: "add" | "set" | "remove";
+        objects: string[];
+    } | {
+        op: "clear";
+    };
+    rewards?: {
+        op: "add" | "set" | "remove";
+        objects: string[];
+    } | {
+        op: "clear";
+    };
+    arbitrations?: {
+        op: "add" | "set" | "remove";
+        objects: string[];
+    } | {
+        op: "clear";
+    };
+    machine?: string | null;
+    discount?: {
+        name: string;
+        count: number;
+    };
+    customer_required?: string[];
+    order_allocators?: object | null;
+    buy_guard?: string | null;
+    compensation_fund_add?: {
+        balance: string | number;
+    };
+    setting_locked_time_add?: number;
+    compensation_fund_receive?: unknown;
+    owner_receive?: unknown;
+    pause?: boolean;
+    publish?: boolean;
+    um?: string | null;
+    order_new?: {
+        buy: {
+            items: Array<{
+                name: string;
+                wip_hash: string;
+            }>;
+        };
+    };
+    current_bPublished?: boolean;
+    current_bPaused?: boolean;
+    current_compensation_fund_balance?: string;
+    current_setting_lock_duration?: string;
+    current_arbitrations_count?: number;
+    current_rewards_count?: number;
+    current_repositories_count?: number;
+    current_sales_count?: number;
+    current_machine_bound?: boolean;
+    current_order_allocators_set?: boolean;
+    builder?: string;
+    target_objects_types?: string[];
+}
+export declare const SERVICE_RISK_VERSION = "1.0.0";
+export declare function getAllServiceRiskRules(): ServiceRiskRule[];
+export declare function getServiceRiskRulesCount(): number;
+export declare function getServiceRiskRulesByCategory(category: ServiceRiskCategory): ServiceRiskRule[];
+export interface ServiceRiskAssessment {
+    summary: string;
+    scene?: ServiceScene;
+    risks: ServiceRisk[];
+    overall_risk: ServiceRiskLevel;
+    risks_by_category: Partial<Record<ServiceRiskCategory, number>>;
+    stakeholder_advice: Partial<Record<ServiceStakeholder, string[]>>;
+    needs_human_review: boolean;
+}
+export declare function assessServiceRisks(ctx: ServiceRiskCheckContext): ServiceRiskAssessment;