@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/order-confirm.js

@@ -0,0 +1,573 @@
+import { MAX_AGENT_COUNT, MAX_DISPUTE_COUNT, } from "@wowok/wowok";
+import { assessOrderRisks, } from "./order-risk.js";
+export const ORDER_PUBLISH_CHECKLIST = [
+    { id: "C-O-01", description: "Order object address is valid (must start with 0x, length >= 40)", passed: false, message: "" },
+    { id: "C-O-02", description: "Operation is NOT direct order::create (Order created via service::buy)", passed: false, message: "" },
+    { id: "C-O-03", description: `agent count <= MAX_AGENT_COUNT (${MAX_AGENT_COUNT}) — ⚠️ actual allows 11 due to <= bug`, passed: false, message: "" },
+    { id: "C-O-04", description: `dispute count < MAX_DISPUTE_COUNT (${MAX_DISPUTE_COUNT}) — cannot file 11th dispute`, passed: false, message: "" },
+    { id: "C-O-05", description: "claimed_by is None (no terminal claim state) — required for arb_confirm/arb_objection/arb_claim_compensation", passed: false, message: "" },
+    { id: "C-O-06", description: "L1 operations (receive/transfer_to/agent_set) called by OWNER only", passed: false, message: "" },
+    { id: "C-O-07", description: "L2 operations (required_info/progress/arb_*) called by owner OR agent", passed: false, message: "" },
+    { id: "C-O-08", description: "agent_set / owner_change called BEFORE Progress binding (frozen after)", passed: false, message: "" },
+    { id: "C-O-09", description: "receive called only when Progress is at terminal node (not delivering)", passed: false, message: "" },
+    { id: "C-O-10", description: "transfer_to / arb_claim_compensation / arb_objection are IRREVERSIBLE — double-confirm", passed: false, message: "" },
+    { id: "C-O-11", description: "required_info is Contact object OR WTS Proof object OR null (clear)", passed: false, message: "" },
+    { id: "C-O-12", description: "Service is published AND not paused (for service::buy flow)", passed: false, message: "" },
+    { id: "C-O-13", description: "Agent CANNOT receive payments — only owner can call receive", passed: false, message: "" },
+    { id: "C-O-14", description: "arb_claim_compensation requires Arb in Arbitrated state", passed: false, message: "" },
+    { id: "C-O-15", description: "Order has 14 fields — SDK uses 'builder' for Move's 'owner' (naming deviation)", passed: false, message: "" },
+];
+function isValidAddress(addr) {
+    return typeof addr === "string" && addr.startsWith("0x") && addr.length >= 40;
+}
+function runStaticChecklist(input) {
+    const items = ORDER_PUBLISH_CHECKLIST.map(c => ({ ...c }));
+    const data = input.order_json;
+    const state = input.current_state ?? {};
+    const caller = input.caller ?? {};
+    const co01 = items.find(i => i.id === "C-O-01");
+    if (!data.object) {
+        co01.passed = false;
+        co01.message = "Order object address is required (creation goes via service::buy, not here)";
+    }
+    else if (!isValidAddress(data.object)) {
+        co01.passed = false;
+        co01.message = `Invalid Order address: ${data.object}`;
+    }
+    else {
+        co01.passed = true;
+    }
+    const co02 = items.find(i => i.id === "C-O-02");
+    co02.passed = true;
+    co02.message = "CallOrder_Data has no create op — Order creation goes via service::buy";
+    const co03 = items.find(i => i.id === "C-O-03");
+    if (data.agent) {
+        const count = data.agent.length;
+        const docValid = count <= MAX_AGENT_COUNT;
+        co03.passed = docValid;
+        co03.message = docValid
+            ? (count === MAX_AGENT_COUNT ? `${count} agents (at doc limit; actual allows 11 due to bug)` : `${count} agents`)
+            : `${count} agents > MAX_AGENT_COUNT (${MAX_AGENT_COUNT}) — will abort E_MAX_AGENT_COUNT (note: actual allows 11 due to <= bug)`;
+    }
+    else {
+        co03.passed = true;
+    }
+    const co04 = items.find(i => i.id === "C-O-04");
+    const disputeCount = state.dispute_count ?? 0;
+    if (data.arb_confirm) {
+        const valid = disputeCount < MAX_DISPUTE_COUNT;
+        co04.passed = valid;
+        co04.message = valid ? `${disputeCount} existing disputes` : `${disputeCount} disputes already at MAX_DISPUTE_COUNT (${MAX_DISPUTE_COUNT}) — next dispute() will abort E_MAX_DISPUTE_COUNT`;
+    }
+    else {
+        co04.passed = true;
+    }
+    const co05 = items.find(i => i.id === "C-O-05");
+    if (data.arb_confirm || data.arb_objection || data.arb_claim_compensation) {
+        const valid = !state.claimed_by_set;
+        co05.passed = valid;
+        co05.message = valid ? "claimed_by is None — arb operations allowed" : "claimed_by is SET — arb operations blocked (E_ORDER_ALREADY_CLAIMED, IRREVERSIBLE)";
+    }
+    else {
+        co05.passed = true;
+    }
+    const co06 = items.find(i => i.id === "C-O-06");
+    const isL1Op = !!(data.receive || data.transfer_to || data.agent);
+    if (isL1Op) {
+        const valid = !!caller.is_owner;
+        co06.passed = valid;
+        co06.message = valid ? "Caller is owner — L1 allowed" : "Caller is NOT owner — L1 operation blocked (E_OWNER)";
+    }
+    else {
+        co06.passed = true;
+    }
+    const co07 = items.find(i => i.id === "C-O-07");
+    const isL2Op = !!(data.required_info !== undefined || data.progress || data.arb_confirm || data.arb_objection || data.arb_claim_compensation);
+    if (isL2Op) {
+        const valid = !!caller.is_owner || !!caller.is_agent;
+        co07.passed = valid;
+        co07.message = valid ? "Caller is owner or agent — L2 allowed" : "Caller is NEITHER owner NOR agent — L2 blocked (E_PERMISSION)";
+    }
+    else {
+        co07.passed = true;
+    }
+    const co08 = items.find(i => i.id === "C-O-08");
+    if (data.agent || (data.transfer_to && !state.progress_bound)) {
+        if (data.agent) {
+            const valid = !state.progress_bound;
+            co08.passed = valid;
+            co08.message = valid ? "Progress not bound — agent_set allowed" : "Progress BOUND — agent_set aborts E_PROGRESS_NOT_SPECIFIED (frozen)";
+        }
+        else {
+            co08.passed = true;
+        }
+    }
+    else {
+        co08.passed = true;
+    }
+    const co09 = items.find(i => i.id === "C-O-09");
+    if (data.receive) {
+        const valid = !!state.progress_at_terminal;
+        co09.passed = valid;
+        co09.message = valid ? "Progress at terminal — receive allowed" : "Progress NOT at terminal — receive aborts E_ORDER_DELIVERING";
+    }
+    else {
+        co09.passed = true;
+    }
+    const co10 = items.find(i => i.id === "C-O-10");
+    const isIrreversible = !!(data.transfer_to || data.arb_claim_compensation || data.arb_objection);
+    if (isIrreversible) {
+        co10.passed = false;
+        co10.message = "Pending user confirmation in Layer 3 (irreversible operation)";
+    }
+    else {
+        co10.passed = true;
+    }
+    const co11 = items.find(i => i.id === "C-O-11");
+    if (data.required_info !== undefined) {
+        const valid = data.required_info === null || isValidAddress(data.required_info);
+        co11.passed = valid;
+        co11.message = valid
+            ? (data.required_info === null ? "required_info = null (clear)" : "required_info is valid address (Contact or WTS Proof)")
+            : `Invalid required_info: ${data.required_info}`;
+    }
+    else {
+        co11.passed = true;
+    }
+    const co12 = items.find(i => i.id === "C-O-12");
+    co12.passed = true;
+    co12.message = "Service check applies only to service::buy flow (not CallOrder_Data)";
+    const co13 = items.find(i => i.id === "C-O-13");
+    if (data.receive && caller.is_agent && !caller.is_owner) {
+        co13.passed = false;
+        co13.message = "Agent CANNOT receive payments — only owner can call receive (L1)";
+    }
+    else {
+        co13.passed = true;
+    }
+    const co14 = items.find(i => i.id === "C-O-14");
+    if (data.arb_claim_compensation) {
+        co14.passed = true;
+        co14.message = "Arb Arbitrated state verified in Layer 4 (Environment)";
+    }
+    else {
+        co14.passed = true;
+    }
+    const co15 = items.find(i => i.id === "C-O-15");
+    co15.passed = true;
+    co15.message = "Informational: SDK ObjectOrder.builder ↔ Move Order.owner (only naming deviation in 22 objects)";
+    return {
+        all_passed: items.filter(i => i.id !== "C-O-10").every(i => i.passed),
+        items,
+    };
+}
+function adaptRiskAssessment(input) {
+    const data = input.order_json;
+    const state = input.current_state ?? {};
+    const caller = input.caller ?? {};
+    let operation;
+    if (data.agent)
+        operation = "agent_set";
+    else if (data.required_info !== undefined)
+        operation = "required_info_update";
+    else if (data.progress)
+        operation = "progress_advance";
+    else if (data.arb_confirm)
+        operation = "arb_confirm";
+    else if (data.arb_objection)
+        operation = "arb_objection";
+    else if (data.arb_claim_compensation)
+        operation = "arb_claim_compensation";
+    else if (data.receive)
+        operation = "receive";
+    else if (data.transfer_to)
+        operation = "transfer_to";
+    const ctx = {
+        object: data.object,
+        operation,
+        is_buy_operation: false,
+        agent_set: data.agent ? { agents: data.agent } : undefined,
+        current_dispute_count: state.dispute_count,
+        claimed_by_set: state.claimed_by_set,
+        progress_bound: state.progress_bound,
+        progress_at_terminal: state.progress_at_terminal,
+        service_published: state.service_published,
+        service_paused: state.service_paused,
+        current_service_machine: state.current_service_machine,
+        order_machine_snapshot: state.order_machine_snapshot,
+        transfer_to_new_owner: data.transfer_to,
+        caller_is_owner: caller.is_owner,
+        caller_is_agent: caller.is_agent,
+    };
+    return assessOrderRisks(ctx);
+}
+export const ORDER_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QO1",
+        question: "Is the Order object address correct? Verify it matches the intended Order (check on explorer).",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QO2",
+        question: "If setting agent list: are all agent addresses trusted parties? Agents can advance Progress and file arbitration but CANNOT receive payments.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-O-3-01"],
+    },
+    {
+        id: "QO3",
+        question: "If filing arbitration (arb_confirm): have you attached all evidence? This operation is IRREVERSIBLE — once filed, the Arb process cannot be cancelled.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-O-4-04"],
+    },
+    {
+        id: "QO4",
+        question: "⚠️⚠️ If claiming compensation (arb_claim_compensation): do you confirm this is the FINAL Arb ruling? After claim, claimed_by is set IRREVERSIBLY — NO new disputes can ever be filed.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-O-3-03", "R-O-4-04"],
+    },
+    {
+        id: "QO5",
+        question: "⚠️⚠️ If transferring ownership (transfer_to): do you confirm the new owner address is correct? This is IRREVERSIBLE — new owner takes over ALL permissions including payment receipt.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-O-4-06"],
+    },
+    {
+        id: "QO6",
+        question: "If advancing Progress: are you sure about the target node? Node transitions are IRREVERSIBLE — no backward movement is possible.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-O-4-03"],
+    },
+    {
+        id: "QO7",
+        question: "If receiving payment: have you verified the receiving object ID and the amount? Funds are forwarded to the owner address immediately.",
+        requires_explicit_yes: false,
+    },
+    {
+        id: "QO8",
+        question: "Have you exported the current Order state as a backup before this operation? (Recommended for irreversible ops.)",
+        requires_explicit_yes: false,
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const data = input.order_json;
+    let questions = [...ORDER_CONFIRMATION_QUESTIONS];
+    if (!data.agent)
+        questions = questions.filter(q => q.id !== "QO2");
+    if (!data.arb_confirm)
+        questions = questions.filter(q => q.id !== "QO3");
+    if (!data.arb_claim_compensation)
+        questions = questions.filter(q => q.id !== "QO4");
+    if (!data.transfer_to)
+        questions = questions.filter(q => q.id !== "QO5");
+    if (!data.progress)
+        questions = questions.filter(q => q.id !== "QO6");
+    if (!data.receive)
+        questions = questions.filter(q => q.id !== "QO7");
+    if (input.skip_user_confirmation) {
+        return {
+            questions_asked: questions,
+            responses: questions.map(q => ({ question_id: q.id, response: "yes" })),
+            all_confirmed: true,
+        };
+    }
+    return {
+        questions_asked: questions,
+        responses: [],
+        all_confirmed: false,
+    };
+}
+function verifyEnvironment(input) {
+    const checks = [];
+    const data = input.order_json;
+    const state = input.current_state ?? {};
+    const caller = input.caller ?? {};
+    if (data.object) {
+        checks.push({
+            name: "order_exists",
+            passed: true,
+            message: `Order ${data.object} assumed to exist (verify via explorer)`,
+        });
+    }
+    const isL1Op = !!(data.receive || data.transfer_to || data.agent);
+    const isL2Op = !!(data.required_info !== undefined || data.progress || data.arb_confirm || data.arb_objection || data.arb_claim_compensation);
+    if (isL1Op) {
+        checks.push({
+            name: "signer_is_owner",
+            passed: !!caller.is_owner,
+            message: caller.is_owner
+                ? "Signer is owner — L1 allowed"
+                : "Signer is NOT owner — L1 operation will abort E_OWNER",
+        });
+    }
+    else if (isL2Op) {
+        const hasPerm = !!caller.is_owner || !!caller.is_agent;
+        checks.push({
+            name: "signer_is_owner_or_agent",
+            passed: hasPerm,
+            message: hasPerm
+                ? `Signer is ${caller.is_owner ? "owner" : "agent"} — L2 allowed`
+                : "Signer is NEITHER owner NOR agent — L2 will abort E_PERMISSION",
+        });
+    }
+    if (data.arb_confirm || data.arb_objection || data.arb_claim_compensation) {
+        checks.push({
+            name: "claimed_by_is_none",
+            passed: !state.claimed_by_set,
+            message: state.claimed_by_set
+                ? "claimed_by is SET — arb operations blocked (E_ORDER_ALREADY_CLAIMED, IRREVERSIBLE)"
+                : "claimed_by is None — arb operations allowed",
+        });
+    }
+    if (data.receive) {
+        checks.push({
+            name: "progress_at_terminal",
+            passed: !!state.progress_at_terminal,
+            message: state.progress_at_terminal
+                ? "Progress at terminal — receive allowed"
+                : "Progress NOT at terminal — receive aborts E_ORDER_DELIVERING",
+        });
+    }
+    if (data.agent) {
+        checks.push({
+            name: "progress_not_bound",
+            passed: !state.progress_bound,
+            message: state.progress_bound
+                ? "Progress BOUND — agent_set aborts E_PROGRESS_NOT_SPECIFIED (frozen)"
+                : "Progress not bound — agent_set allowed",
+        });
+    }
+    if (data.arb_confirm) {
+        const count = state.dispute_count ?? 0;
+        const valid = count < MAX_DISPUTE_COUNT;
+        checks.push({
+            name: "dispute_count_below_max",
+            passed: valid,
+            message: valid
+                ? `${count} disputes (< MAX_DISPUTE_COUNT ${MAX_DISPUTE_COUNT})`
+                : `${count} disputes at MAX_DISPUTE_COUNT — next dispute() aborts E_MAX_DISPUTE_COUNT`,
+        });
+    }
+    if (state.service_published === false) {
+        checks.push({
+            name: "service_published",
+            passed: false,
+            message: "Service is NOT published — service::buy will fail",
+        });
+    }
+    if (state.service_paused === true) {
+        checks.push({
+            name: "service_not_paused",
+            passed: false,
+            message: "Service is PAUSED — service::buy will fail",
+        });
+    }
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const ORDER_CONFIRM_VERSION = "1.0.0";
+export function runOrderConfirmGate(input) {
+    const layersPassed = [];
+    const layersFailed = [];
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        layersFailed.push("L1_checklist");
+        return {
+            status: "blocked_checklist",
+            checklist_result: checklist,
+            confirmation_text: generateConfirmationText(input, checklist),
+            block_reason: `Checklist failed: ${checklist.items.filter(i => !i.passed).map(i => i.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: ORDER_CONFIRM_VERSION,
+                final_status: "blocked_checklist",
+                layers_passed: layersPassed,
+                layers_failed: layersFailed,
+            },
+        };
+    }
+    layersPassed.push("L1_checklist");
+    const assessment = adaptRiskAssessment(input);
+    const hasCritical = assessment.risks.some(r => r.level === "CRITICAL");
+    if (hasCritical) {
+        layersFailed.push("L2_risk");
+        return {
+            status: "blocked_risk",
+            checklist_result: checklist,
+            risk_result: assessment,
+            confirmation_text: generateConfirmationText(input, checklist, assessment),
+            block_reason: `CRITICAL risks: ${assessment.risks.filter(r => r.level === "CRITICAL").map(r => r.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: ORDER_CONFIRM_VERSION,
+                final_status: "blocked_risk",
+                layers_passed: layersPassed,
+                layers_failed: layersFailed,
+            },
+        };
+    }
+    layersPassed.push("L2_risk");
+    const userConf = processUserConfirmation(input, assessment);
+    if (!userConf.all_confirmed) {
+        const isIrreversible = !!(input.order_json.transfer_to || input.order_json.arb_claim_compensation || input.order_json.arb_objection);
+        if (isIrreversible) {
+            const co10 = checklist.items.find(i => i.id === "C-O-10");
+            if (co10) {
+                const relevantQIds = [];
+                if (input.order_json.transfer_to)
+                    relevantQIds.push("QO5");
+                if (input.order_json.arb_claim_compensation)
+                    relevantQIds.push("QO4");
+                if (input.order_json.arb_objection)
+                    relevantQIds.push("QO3");
+                const confirmed = relevantQIds.every(qid => {
+                    const r = userConf.responses.find(r => r.question_id === qid);
+                    return r?.response === "yes";
+                });
+                co10.passed = confirmed;
+                co10.message = confirmed ? "" : "Irreversible operation not confirmed by user";
+            }
+        }
+        if (isIrreversible) {
+            const co10 = checklist.items.find(i => i.id === "C-O-10");
+            if (co10 && !co10.passed) {
+                layersFailed.push("L3_user");
+                return {
+                    status: "blocked_user",
+                    checklist_result: checklist,
+                    risk_result: assessment,
+                    user_confirmation: userConf,
+                    confirmation_text: generateConfirmationText(input, checklist, assessment),
+                    block_reason: "User did not confirm irreversible operation",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: ORDER_CONFIRM_VERSION,
+                        final_status: "blocked_user",
+                        layers_passed: layersPassed,
+                        layers_failed: layersFailed,
+                    },
+                };
+            }
+        }
+    }
+    layersPassed.push("L3_user");
+    if (input.skip_environment_check) {
+        layersPassed.push("L4_environment");
+    }
+    else {
+        const env = verifyEnvironment(input);
+        if (!env.passed) {
+            layersFailed.push("L4_environment");
+            return {
+                status: "blocked_environment",
+                checklist_result: checklist,
+                risk_result: assessment,
+                user_confirmation: userConf,
+                environment_result: env,
+                confirmation_text: generateConfirmationText(input, checklist, assessment),
+                block_reason: `Environment check failed: ${env.checks.filter(c => !c.passed).map(c => c.name).join(", ")}`,
+                decision_record: {
+                    timestamp: new Date().toISOString(),
+                    gate_version: ORDER_CONFIRM_VERSION,
+                    final_status: "blocked_environment",
+                    layers_passed: layersPassed,
+                    layers_failed: layersFailed,
+                },
+            };
+        }
+        layersPassed.push("L4_environment");
+    }
+    return {
+        status: "approved",
+        checklist_result: checklist,
+        risk_result: assessment,
+        user_confirmation: userConf,
+        confirmation_text: generateConfirmationText(input, checklist, assessment),
+        decision_record: {
+            timestamp: new Date().toISOString(),
+            gate_version: ORDER_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.order_json;
+    lines.push("═══ Order Confirmation ═══");
+    lines.push("");
+    if (data.object) {
+        lines.push(`Order: ${data.object}`);
+    }
+    else {
+        lines.push("Order: (no address — invalid for CallOrder_Data)");
+    }
+    lines.push("");
+    lines.push("─ Operations ──────────────────");
+    if (data.agent)
+        lines.push(`- ⚠️ Set agent list: ${data.agent.length} agent(s) [L1, owner-only, frozen after progress]`);
+    if (data.required_info !== undefined)
+        lines.push(`- required_info: ${data.required_info === null ? "(clear)" : data.required_info} [L2]`);
+    if (data.progress)
+        lines.push(`- Advance Progress: ${data.progress.next_node_name ?? "?"} [L2, irreversible]`);
+    if (data.arb_confirm)
+        lines.push(`- ⚠️ File arbitration: ${data.arb_confirm.arb} [L2, irreversible]`);
+    if (data.arb_objection)
+        lines.push(`- ⚠️ Object to Arb: ${data.arb_objection.arb} [L2, irreversible]`);
+    if (data.arb_claim_compensation)
+        lines.push(`- ⚠️⚠️ Claim compensation: ${data.arb_claim_compensation.arb} [L2, ONE-TIME, IRREVERSIBLE]`);
+    if (data.receive)
+        lines.push(`- Receive: ${data.receive.received} [L1, owner-only]`);
+    if (data.transfer_to)
+        lines.push(`- ⚠️⚠️ Transfer ownership to: ${data.transfer_to} [L1, IRREVERSIBLE]`);
+    lines.push("");
+    lines.push("─ Checklist ──────────────────");
+    for (const item of checklist.items) {
+        const mark = item.passed ? "✓" : "✗";
+        lines.push(`  ${mark} ${item.id}: ${item.description}${item.message ? " — " + item.message : ""}`);
+    }
+    lines.push("");
+    if (assessment) {
+        lines.push("─ Risk Assessment ──────────────────");
+        lines.push(`Overall: ${assessment.overall_risk}`);
+        lines.push(`Detected: ${assessment.risks.length} risk(s)`);
+        for (const r of assessment.risks) {
+            lines.push(`  [${r.level}] ${r.id}: ${r.title}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function progressiveOrderCheck(input) {
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        return {
+            stage: "checklist",
+            status: "fail",
+            message: `Checklist failed: ${checklist.items.filter(i => !i.passed).map(i => i.id).join(", ")}`,
+            next_action: "Fix failing checklist items",
+        };
+    }
+    const assessment = adaptRiskAssessment(input);
+    if (assessment.risks.some(r => r.level === "CRITICAL")) {
+        return {
+            stage: "risk",
+            status: "fail",
+            message: `CRITICAL risks: ${assessment.risks.filter(r => r.level === "CRITICAL").map(r => r.id).join(", ")}`,
+            next_action: "Resolve CRITICAL risks before proceeding",
+        };
+    }
+    if (assessment.needs_human_review) {
+        return {
+            stage: "confirmation",
+            status: "pending",
+            message: "Human review required for HIGH risks",
+            next_action: "Confirm risk acceptance",
+        };
+    }
+    return {
+        stage: "complete",
+        status: "pass",
+        message: "All checks passed",
+    };
+}

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

@@ -0,0 +1,66 @@
+import { type OrderScene, type OrderPermissionLayer, type OrderLifecycleEvent } from "./order-ledger.js";
+import { type OrderTemplate } from "./order-templates.js";
+import { type SemanticToSchemaRule } from "./order-translation.js";
+import { type OrderRiskRule, type OrderRiskAssessment, type OrderStakeholder, type OrderRiskCheckContext } from "./order-risk.js";
+import { verifySnapshotMechanism, type OrderPuzzle, type OrderPuzzleCompleteness } from "./order-puzzle.js";
+import { ORDER_PUBLISH_CHECKLIST, ORDER_CONFIRMATION_QUESTIONS, type OrderJsonForConfirm } from "./order-confirm.js";
+export declare const ORDER_CONTEXT_VERSION = "1.0.0";
+export type OrderInjectionMode = "initial_design" | "mid_design_review" | "pre_execute" | "post_create_monitor" | "stakeholder_review" | "dispute_resolution";
+export type OrderStakeholderPerspective = OrderStakeholder | "system";
+export interface OrderContextBundle {
+    version: string;
+    mode: OrderInjectionMode;
+    stakeholder_perspective?: OrderStakeholderPerspective;
+    matched_scene?: OrderScene;
+    matched_template?: OrderTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: OrderPuzzle;
+    puzzle_completeness?: OrderPuzzleCompleteness;
+    relevant_risks: OrderRiskRule[];
+    risk_assessment?: OrderRiskAssessment;
+    relevant_checklist: typeof ORDER_PUBLISH_CHECKLIST;
+    relevant_questions: typeof ORDER_CONFIRMATION_QUESTIONS;
+    cross_object_refs: OrderCrossObjectRef[];
+    onchain_constraints: OrderOnchainConstraint[];
+    rendering_hints: OrderRenderingHints;
+    snapshot_verification?: ReturnType<typeof verifySnapshotMechanism>;
+    event_audit?: {
+        emitted: OrderLifecycleEvent[];
+        inferred: OrderLifecycleEvent[];
+    };
+}
+export interface OrderCrossObjectRef {
+    object: "Service" | "Machine" | "Progress" | "Allocation" | "Arbitration" | "Repository" | "Demand" | "Discount" | "Contact" | "WTS_Proof";
+    field: string;
+    scene_id: string;
+    description: string;
+}
+export interface OrderOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface OrderRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_immutability_warning: boolean;
+    include_irreversible_warning: boolean;
+    include_snapshot_warning: boolean;
+    include_claimed_by_warning: boolean;
+    max_length: number;
+}
+export interface BuildOrderContextInput {
+    mode: OrderInjectionMode;
+    intent?: string;
+    order_json?: OrderJsonForConfirm;
+    stakeholder?: OrderStakeholderPerspective;
+    target_operation_field?: OrderScene["operation_field"];
+    target_permission_layer?: OrderPermissionLayer;
+    max_length?: number;
+    current_state?: OrderRiskCheckContext;
+}
+export declare function buildOrderContext(input: BuildOrderContextInput): OrderContextBundle;
+export declare function buildPromptFromOrderContext(bundle: OrderContextBundle): string;
+export declare function getOrderContextSummary(bundle: OrderContextBundle): string;
+export declare function getStakeholderAdvice(stakeholder: OrderStakeholderPerspective, scene?: OrderScene): string[];