@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/order-puzzle.js

@@ -0,0 +1,255 @@
+import { MAX_AGENT_COUNT, } from "@wowok/wowok";
+import { ORDER_SCENES, findSceneById, inferSceneFromIntent, } from "./order-ledger.js";
+export function initPuzzleFromIntent(intent) {
+    const puzzle = {};
+    if (intent.action || intent.rule_sentence) {
+        puzzle.intent = {
+            action: intent.action ?? "buy",
+            lifecycle_phase: intent.lifecycle_phase ?? "P-O-01_Created",
+            rule_sentence: intent.rule_sentence ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        };
+    }
+    puzzle.constraints = {
+        F_O_01_no_permission_uses_owner_agent: true,
+        F_O_02_machine_is_snapshot: true,
+        F_O_03_compound_creation_via_service_buy: true,
+        F_O_04_progress_binding_freezes_owner_agent: true,
+        F_O_05_claimed_by_irreversible_blocks_dispute: true,
+        F_O_06_only_new_order_event_emitted: true,
+        F_O_07_dispute_max_10: true,
+        F_O_08_agent_max_10_actual_11: true,
+        F_O_09_no_store_cannot_be_nested: true,
+        F_O_10_sdk_builder_equals_move_owner: true,
+        F_O_11_receive_blocks_during_delivering: true,
+        F_O_12_agent_cannot_receive: true,
+        F_O_13_e_progress_not_specified_dual_semantics: true,
+        F_O_14_buy_is_atomic: true,
+        F_O_15_package_only_callbacks: true,
+        F_O_16_order_allocation_1_to_1: true,
+        F_O_17_order_progress_1_to_1: true,
+        F_O_18_wip_hash_no_empty_string: true,
+        F_O_19_saleitem_item_to_purchaseditem_name: true,
+        F_O_20_time_auto_set: true,
+        F_O_21_new_order_event_fields: true,
+        F_O_22_required_info_contact_or_wts: true,
+        F_O_23_transfer_to_irreversible: true,
+        F_O_24_sdk_no_client_side_count_check: true,
+        F_O_25_service_decoupled_after_publish: 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 + rule_sentence)" });
+    }
+    else if (!puzzle.intent.rule_sentence) {
+        missing.push("A");
+        missing_details.push({ dimension: "A", reason: "rule_sentence is empty" });
+    }
+    if (!puzzle.binding) {
+        if (puzzle.intent?.action === "buy") {
+            missing.push("B");
+            missing_details.push({ dimension: "B", reason: "Binding not specified (service + items + owner)" });
+        }
+    }
+    else if (puzzle.intent?.action === "buy" && !puzzle.binding.service) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "service address missing" });
+    }
+    if (!puzzle.data_source && puzzle.intent?.action === "buy") {
+        missing.push("C");
+        missing_details.push({ dimension: "C", reason: "Data source not specified (where fields come from)" });
+    }
+    if (!puzzle.operations) {
+        if (puzzle.intent && puzzle.intent.action !== "buy") {
+            missing.push("D");
+            missing_details.push({ dimension: "D", reason: "Operations not enumerated" });
+        }
+    }
+    if (!puzzle.logic) {
+        missing.push("E");
+        missing_details.push({ dimension: "E", reason: "Logic flow not defined (state transitions + mutex)" });
+    }
+    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.binding) {
+        const b = puzzle.binding;
+        if (b.agents.length > MAX_AGENT_COUNT) {
+            violations.push({
+                constraint_id: "F-O-08",
+                severity: "HIGH",
+                message: `Agent count ${b.agents.length} exceeds MAX_AGENT_COUNT ${MAX_AGENT_COUNT} (⚠️ Move actually allows 11 due to <= bug)`,
+                current_value: b.agents.length,
+                limit: MAX_AGENT_COUNT,
+            });
+        }
+        for (const item of b.items) {
+            if (!item.wip_hash || item.wip_hash === "") {
+                violations.push({
+                    constraint_id: "F-O-18",
+                    severity: "HIGH",
+                    message: `Item "${item.name}" has empty wip_hash (Move rejects empty string)`,
+                });
+            }
+        }
+    }
+    if (puzzle.operations) {
+        for (const op of puzzle.operations.operations) {
+            if (op.type === "agent_set" && puzzle.binding?.progress) {
+                violations.push({
+                    constraint_id: "F-O-04",
+                    severity: "HIGH",
+                    message: "Cannot set agent: Progress already bound (aborts E_PROGRESS_NOT_SPECIFIED — note dual semantics)",
+                });
+            }
+            if (op.type === "transfer_to") {
+                violations.push({
+                    constraint_id: "F-O-23",
+                    severity: "CRITICAL",
+                    message: `transfer_to is IRREVERSIBLE — new owner ${op.new_owner} will take over ALL permissions`,
+                });
+            }
+            if (op.type === "agent_set" && op.agents.length > MAX_AGENT_COUNT) {
+                violations.push({
+                    constraint_id: "F-O-08",
+                    severity: "HIGH",
+                    message: `agent_set with ${op.agents.length} agents exceeds MAX_AGENT_COUNT ${MAX_AGENT_COUNT}`,
+                    current_value: op.agents.length,
+                    limit: MAX_AGENT_COUNT,
+                });
+            }
+        }
+    }
+    return violations;
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [];
+    lines.push("═══ Order Confirmation ═══");
+    lines.push("");
+    if (puzzle.intent) {
+        lines.push(`Action: ${puzzle.intent.action}`);
+        lines.push(`Lifecycle phase: ${puzzle.intent.lifecycle_phase}`);
+        lines.push(`Intent: ${puzzle.intent.rule_sentence}`);
+        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) {
+        const b = puzzle.binding;
+        lines.push("─ Binding (Service snapshot) ──────────────");
+        lines.push(`Service: ${b.service}`);
+        lines.push(`Machine snapshot: ${b.machine_snapshot ?? "(none — no workflow)"}`);
+        lines.push(`Discount: ${b.discount ?? "(none)"}`);
+        lines.push(`Items: ${b.items.length}`);
+        for (const i of b.items) {
+            lines.push(`  - ${i.name} x${i.quantity} @ ${i.price} (wip: ${i.wip_hash.slice(0, 10)}...)`);
+        }
+        lines.push(`Amount: ${b.amount} MIST`);
+        lines.push(`Owner (Move) / Builder (SDK): ${b.owner}`);
+        lines.push(`Agents: ${b.agents.length > 0 ? b.agents.join(", ") : "(none)"}`);
+        lines.push(`Progress: ${b.progress ?? "(not bound)"}`);
+        lines.push(`Allocation: ${b.allocation ?? "(not bound)"}`);
+        lines.push("");
+    }
+    if (puzzle.data_source) {
+        lines.push("─ Data Source ──────────────");
+        const d = puzzle.data_source;
+        lines.push(`Service: ${d.service_source}`);
+        lines.push(`Machine: ${d.machine_source}`);
+        lines.push(`Amount: ${d.amount_source}`);
+        lines.push(`Owner: ${d.owner_source}`);
+        if (d.progress_source !== "none")
+            lines.push(`Progress: ${d.progress_source}`);
+        if (d.allocation_source !== "none")
+            lines.push(`Allocation: ${d.allocation_source}`);
+        lines.push("");
+    }
+    if (puzzle.operations && puzzle.operations.operations.length > 0) {
+        lines.push("─ Operations ──────────────");
+        for (const op of puzzle.operations.operations)
+            lines.push(`  - ${JSON.stringify(op)}`);
+        lines.push("");
+    }
+    if (puzzle.logic) {
+        lines.push("─ Logic ──────────────");
+        lines.push(`State transitions: ${puzzle.logic.state_transitions.length}`);
+        lines.push(`Field mutex rules: ${puzzle.logic.field_mutex.length}`);
+        lines.push(`Cross-object flows: ${puzzle.logic.cross_object_flows.length}`);
+        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 verifySnapshotMechanism(puzzle) {
+    if (!puzzle.binding) {
+        return { snapshot_understood: false, message: "Binding not specified — cannot verify snapshot" };
+    }
+    if (puzzle.binding.machine_snapshot && !puzzle.data_source) {
+        return {
+            snapshot_understood: false,
+            message: "machine_snapshot set but data_source missing — cannot confirm snapshot semantics",
+        };
+    }
+    if (puzzle.binding.machine_snapshot && puzzle.data_source?.machine_source !== "service_machine_snapshot") {
+        return {
+            snapshot_understood: false,
+            message: `machine_source is ${puzzle.data_source?.machine_source}, expected "service_machine_snapshot"`,
+        };
+    }
+    return {
+        snapshot_understood: true,
+        message: "Snapshot mechanism correctly captured: machine is copied from service.machine at buy time",
+    };
+}
+export function inferLifecyclePhase(order) {
+    if (order.claimed_by)
+        return "P-O-04_Claimed";
+    if (order.progress) {
+        if (order.progress_at_terminal)
+            return "P-O-05_Completed";
+        if (order.progress_at_cancel)
+            return "P-O-06_Cancelled";
+        return "P-O-02_Progressing";
+    }
+    if (order.dispute && order.dispute.length > 0)
+        return "P-O-03_Disputed";
+    return "P-O-01_Created";
+}
+export function matchSceneFromPuzzle(puzzle) {
+    if (!puzzle.intent)
+        return undefined;
+    return inferSceneFromIntent(puzzle.intent.rule_sentence) ?? inferSceneFromIntent(puzzle.intent.action);
+}
+export function listAllScenes() {
+    return ORDER_SCENES;
+}
+export function lookupScene(id) {
+    return findSceneById(id);
+}

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

@@ -0,0 +1,66 @@
+import { type OrderScene, type OrderPermissionLayer } from "./order-ledger.js";
+export type OrderRiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+export type OrderRiskCategory = "structural" | "semantic" | "authority" | "lifecycle" | "cross_object";
+export interface OrderRisk {
+    id: string;
+    level: OrderRiskLevel;
+    category: OrderRiskCategory;
+    title: string;
+    description: string;
+    affected_stakeholders: OrderStakeholder[];
+    scenario: string;
+    mitigation: string;
+    evidence?: string;
+}
+export type OrderStakeholder = "owner" | "agent" | "arbitrator" | "service_provider" | "system";
+export interface OrderRiskRule {
+    id: string;
+    category: OrderRiskCategory;
+    trigger: string;
+    check: (ctx: OrderRiskCheckContext) => OrderRisk | null;
+}
+export interface OrderRiskCheckContext {
+    object?: string;
+    is_buy_operation?: boolean;
+    agent_set?: {
+        agents: string[];
+    };
+    current_dispute_count?: number;
+    claimed_by_set?: boolean;
+    progress_bound?: boolean;
+    operation?: "agent_set" | "required_info_update" | "progress_advance" | "arb_confirm" | "arb_objection" | "arb_claim_compensation" | "receive" | "transfer_to" | "service_buy";
+    items?: {
+        name: string;
+        price: string;
+        quantity: string;
+        wip_hash: string;
+    }[];
+    service_published?: boolean;
+    service_paused?: boolean;
+    current_service_machine?: string;
+    order_machine_snapshot?: string;
+    progress_at_terminal?: boolean;
+    transfer_to_new_owner?: string;
+    caller_is_owner?: boolean;
+    caller_is_agent?: boolean;
+}
+export declare const ORDER_RISK_VERSION = "1.0.0";
+export declare function getAllOrderRiskRules(): OrderRiskRule[];
+export declare function getOrderRiskRulesCount(): number;
+export declare function getOrderRiskRulesByCategory(category: OrderRiskCategory): OrderRiskRule[];
+export declare function getOrderRiskRuleById(id: string): OrderRiskRule | undefined;
+export interface OrderRiskAssessment {
+    summary: string;
+    scene?: OrderScene;
+    risks: OrderRisk[];
+    overall_risk: OrderRiskLevel;
+    risks_by_category: Partial<Record<OrderRiskCategory, number>>;
+    stakeholder_advice: Partial<Record<OrderStakeholder, string[]>>;
+    needs_human_review: boolean;
+}
+export declare function assessOrderRisks(ctx: OrderRiskCheckContext): OrderRiskAssessment;
+export declare function checkPermissionLayer(operation: string, caller_is_owner: boolean, caller_is_agent: boolean): {
+    allowed: boolean;
+    layer: OrderPermissionLayer;
+    reason?: string;
+};