@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/arbitration-confirm.js

@@ -0,0 +1,559 @@
+import { MAX_VOTING_GUARD_COUNT, } from "@wowok/wowok";
+import { isTerminalArbStatus, isValidArbStatusTransition, } from "./arbitration-ledger.js";
+import { assessArbitrationRisks, } from "./arbitration-risk.js";
+export const ARBITRATION_OPERATION_CHECKLIST = [
+    { id: "C-AB-01", description: "object field present (STRING for existing, OBJECT for new)", passed: false, message: "" },
+    { id: "C-AB-02", description: "coin_type valid for new Arbitration (e.g. 0x2::wow::WOW)", passed: false, message: "" },
+    { id: "C-AB-03", description: "permission_address valid (Contact/Permission object)", passed: false, message: "" },
+    { id: "C-AB-04", description: "fee (u64) non-negative; dispute fee >= Arbitration.fee", passed: false, message: "" },
+    { id: "C-AB-05", description: "voting_guard count <= MAX_VOTING_GUARD_COUNT (50)", passed: false, message: "" },
+    { id: "C-AB-06", description: "voting_guard no duplicate addresses", passed: false, message: "" },
+    { id: "C-AB-07", description: "Arb status transition valid (7-state flow)", passed: false, message: "" },
+    { id: "C-AB-08", description: "Operation allowed in current Arb status (not terminal-blocked)", passed: false, message: "" },
+    { id: "C-AB-09", description: "voting_guard / usage_guard dual-Guard coherent with operation", passed: false, message: "" },
+    { id: "C-AB-10", description: "VoteValue weight type valid (GuardIdentifier u8 / FixedValue u32)", passed: false, message: "" },
+    { id: "C-AB-11", description: "Order op permission verified (for dispute)", passed: false, message: "" },
+    { id: "C-AB-12", description: "Ownership transfer (builder) double-confirmed", passed: false, message: "" },
+];
+function runStaticChecklist(input) {
+    const items = ARBITRATION_OPERATION_CHECKLIST.map(c => ({ ...c }));
+    const data = input.arbitration_json;
+    const objValid = data.object !== undefined && data.object !== null;
+    const c01 = items.find(i => i.id === "C-AB-01");
+    c01.passed = objValid;
+    c01.message = objValid ? "" : "object field is required (STRING for existing, OBJECT for new)";
+    const c02 = items.find(i => i.id === "C-AB-02");
+    if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        const valid = !!obj.type_parameter && obj.type_parameter.includes("::");
+        c02.passed = valid;
+        c02.message = valid ? "" : "type_parameter must be a valid Coin type (e.g. 0x2::wow::WOW)";
+    }
+    else {
+        c02.passed = true;
+    }
+    const c03 = items.find(i => i.id === "C-AB-03");
+    if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        const valid = !!obj.permission;
+        c03.passed = valid;
+        c03.message = valid ? "" : "permission is required for new Arbitration";
+    }
+    else {
+        c03.passed = true;
+    }
+    const c04 = items.find(i => i.id === "C-AB-04");
+    if (data.fee !== undefined) {
+        const feeNum = typeof data.fee === "string" ? BigInt(data.fee) : BigInt(data.fee);
+        const valid = feeNum >= 0;
+        c04.passed = valid;
+        c04.message = valid ? "" : `fee ${data.fee} must be >= 0`;
+    }
+    else if (data.dispute && input.current_arbitration_fee !== undefined) {
+        const required = typeof input.current_arbitration_fee === "string"
+            ? BigInt(input.current_arbitration_fee)
+            : BigInt(input.current_arbitration_fee);
+        const provided = data.dispute.fee && typeof data.dispute.fee === "object" && "balance" in data.dispute.fee
+            ? BigInt(data.dispute.fee.balance ?? 0)
+            : BigInt(0);
+        const valid = provided >= required;
+        c04.passed = valid;
+        c04.message = valid ? "" : `dispute fee ${provided.toString()} < required ${required.toString()}`;
+    }
+    else {
+        c04.passed = true;
+    }
+    const c05 = items.find(i => i.id === "C-AB-05");
+    if (data.voting_guard && (data.voting_guard.op === "add" || data.voting_guard.op === "set") && data.voting_guard.guards) {
+        const newCount = data.voting_guard.op === "set"
+            ? data.voting_guard.guards.length
+            : (input.current_voting_guard_count ?? 0) + data.voting_guard.guards.length;
+        const valid = newCount <= MAX_VOTING_GUARD_COUNT;
+        c05.passed = valid;
+        c05.message = valid ? "" : `voting_guard count ${newCount} > ${MAX_VOTING_GUARD_COUNT}`;
+    }
+    else {
+        c05.passed = true;
+    }
+    const c06 = items.find(i => i.id === "C-AB-06");
+    if (data.voting_guard && (data.voting_guard.op === "add" || data.voting_guard.op === "set") && data.voting_guard.guards) {
+        const addrs = data.voting_guard.guards.map(g => g.guard);
+        const dupes = addrs.filter((a, i) => addrs.indexOf(a) !== i);
+        const valid = dupes.length === 0;
+        c06.passed = valid;
+        c06.message = valid ? "" : `Duplicate guards: ${dupes.join(", ")}`;
+    }
+    else {
+        c06.passed = true;
+    }
+    const c07 = items.find(i => i.id === "C-AB-07");
+    if (input.current_arb_status && input.expected_arb_status) {
+        if (input.current_arb_status === input.expected_arb_status) {
+            c07.passed = true;
+        }
+        else {
+            const valid = isValidArbStatusTransition(input.current_arb_status, input.expected_arb_status);
+            c07.passed = valid;
+            c07.message = valid ? "" : `Invalid transition: ${input.current_arb_status} → ${input.expected_arb_status}`;
+        }
+    }
+    else {
+        c07.passed = true;
+    }
+    const c08 = items.find(i => i.id === "C-AB-08");
+    if (input.current_arb_status && isTerminalArbStatus(input.current_arb_status)) {
+        const allowedOp = !!data.arb_withdraw;
+        const blockedOp = !!(data.vote || data.confirm || data.arbitration || data.reset || data.feedback);
+        const valid = allowedOp && !blockedOp;
+        c08.passed = valid;
+        c08.message = valid ? "" : `Terminal status ${input.current_arb_status} only allows arb_withdraw`;
+    }
+    else {
+        c08.passed = true;
+    }
+    const c09 = items.find(i => i.id === "C-AB-09");
+    if (data.vote && data.vote.voting_guard) {
+        if (!input.current_voting_guard_addresses || input.current_voting_guard_addresses.length === 0) {
+            c09.passed = false;
+            c09.message = "vote.voting_guard provided but Arbitration.voting_guard is empty";
+        }
+        else if (!input.current_voting_guard_addresses.includes(data.vote.voting_guard)) {
+            c09.passed = false;
+            c09.message = `vote.voting_guard ${data.vote.voting_guard} not in list`;
+        }
+        else {
+            c09.passed = true;
+        }
+    }
+    else if (data.vote && !data.vote.voting_guard && input.current_voting_guard_addresses && input.current_voting_guard_addresses.length > 0) {
+        c09.passed = false;
+        c09.message = "vote without voting_guard but Arbitration.voting_guard is non-empty (use vote_with_voting_guard)";
+    }
+    else {
+        c09.passed = true;
+    }
+    const c10 = items.find(i => i.id === "C-AB-10");
+    if (data.voting_guard && (data.voting_guard.op === "add" || data.voting_guard.op === "set") && data.voting_guard.guards) {
+        let valid = true;
+        let msg = "";
+        for (const g of data.voting_guard.guards) {
+            const vw = g.vote_weight;
+            if (!vw) {
+                valid = false;
+                msg = "Missing vote_weight";
+                break;
+            }
+            if ("GuardIdentifier" in vw && vw.GuardIdentifier !== undefined) {
+                if (vw.GuardIdentifier > 255) {
+                    valid = false;
+                    msg = `GuardIdentifier ${vw.GuardIdentifier} > u8 max (255)`;
+                    break;
+                }
+            }
+            if ("FixedValue" in vw && vw.FixedValue !== undefined) {
+                if (vw.FixedValue > 4294967295) {
+                    valid = false;
+                    msg = `FixedValue ${vw.FixedValue} > u32 max`;
+                    break;
+                }
+            }
+        }
+        c10.passed = valid;
+        c10.message = msg;
+    }
+    else {
+        c10.passed = true;
+    }
+    const c11 = items.find(i => i.id === "C-AB-11");
+    if (data.dispute) {
+        c11.passed = false;
+        c11.message = "Pending environment verification (Layer 4)";
+    }
+    else {
+        c11.passed = true;
+    }
+    const c12 = items.find(i => i.id === "C-AB-12");
+    if (data.builder) {
+        c12.passed = false;
+        c12.message = "Pending user confirmation in Layer 3";
+    }
+    else {
+        c12.passed = true;
+    }
+    return {
+        all_passed: items.filter(i => i.id !== "C-AB-11" && i.id !== "C-AB-12").every(i => i.passed),
+        items,
+    };
+}
+function adaptRiskAssessment(input) {
+    const ctx = {
+        object: typeof input.arbitration_json.object === "string" ? input.arbitration_json.object : null,
+        description: input.arbitration_json.description,
+        location: input.arbitration_json.location,
+        fee: input.arbitration_json.fee,
+        pause: input.arbitration_json.pause,
+        dispute: input.arbitration_json.dispute,
+        confirm: input.arbitration_json.confirm,
+        voting_deadline_change: input.arbitration_json.voting_deadline_change,
+        vote: input.arbitration_json.vote,
+        feedback: input.arbitration_json.feedback,
+        arbitration: input.arbitration_json.arbitration,
+        reset: input.arbitration_json.reset,
+        arb_withdraw: input.arbitration_json.arb_withdraw,
+        fees_transfer: input.arbitration_json.fees_transfer,
+        usage_guard: input.arbitration_json.usage_guard,
+        voting_guard: input.arbitration_json.voting_guard,
+        um: input.arbitration_json.um,
+        builder: input.arbitration_json.builder,
+        current_arb_status: input.current_arb_status,
+        expected_arb_status: input.expected_arb_status,
+        current_voting_guard_count: input.current_voting_guard_count,
+        current_voting_guard_addresses: input.current_voting_guard_addresses,
+        current_arbitration_fee: input.current_arbitration_fee,
+        current_bPaused: input.current_bPaused,
+        current_timestamp_ms: input.current_timestamp_ms,
+        target_objects_types: input.target_objects_types,
+    };
+    return assessArbitrationRisks(ctx);
+}
+export const ARBITRATION_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QAB1",
+        question: "Are all arbiter/voter addresses correctly granted ARBITRATION_VOTE (358) on the Permission object?",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QAB2",
+        question: "Is the voting_guard configuration correct? (Each guard address is a valid Guard object that arbiters can submit Passport for)",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-AB-2-01"],
+    },
+    {
+        id: "QAB3",
+        question: "If filing a dispute: have you verified the Order op permission (signer must have Order's dispute permission)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-AB-5-02"],
+    },
+    {
+        id: "QAB4",
+        question: "If making a ruling (arbitration op): is the indemnity amount correct? This will be paid via order::compensate (IRREVERSIBLE).",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-AB-3-03"],
+    },
+    {
+        id: "QAB5",
+        question: "⚠️ If transferring ownership (builder field): do you confirm the new owner address is correct? This operation is IRREVERSIBLE.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-AB-3-02"],
+    },
+    {
+        id: "QAB6",
+        question: "If allocating fees (fees_transfer): have you verified the destination Allocation/Treasury has a fair distribution policy for arbiters?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-AB-5-01"],
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const questions = [...ARBITRATION_CONFIRMATION_QUESTIONS];
+    if (!input.arbitration_json.dispute) {
+        const idx = questions.findIndex(q => q.id === "QAB3");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.arbitration_json.arbitration) {
+        const idx = questions.findIndex(q => q.id === "QAB4");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.arbitration_json.builder) {
+        const idx = questions.findIndex(q => q.id === "QAB5");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.arbitration_json.fees_transfer) {
+        const idx = questions.findIndex(q => q.id === "QAB6");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    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 = [];
+    if (typeof input.arbitration_json.object === "string") {
+        checks.push({
+            name: "object_exists",
+            passed: true,
+            message: `Arbitration object ${input.arbitration_json.object} assumed to exist`,
+        });
+    }
+    const op = input.arbitration_json;
+    const requiresPerm = !!(op.description || op.location || op.fee || op.pause || op.confirm ||
+        op.vote || op.feedback || op.arbitration || op.reset || op.arb_withdraw ||
+        op.fees_transfer || op.usage_guard !== undefined || op.voting_guard ||
+        op.um !== undefined);
+    if (requiresPerm) {
+        checks.push({
+            name: "signer_has_permission",
+            passed: true,
+            message: "Signer must have the relevant ARBITRATION_* permission index (350-368)",
+        });
+    }
+    const arbOp = op.confirm || op.vote || op.feedback || op.arbitration || op.reset || op.arb_withdraw;
+    if (arbOp) {
+        checks.push({
+            name: "arb_belongs_to_arbitration",
+            passed: true,
+            message: "Arb.arbitration_address must match this Arbitration (else E_ARBITRATION_ARB_NOT_MATCH)",
+        });
+    }
+    if (op.dispute) {
+        checks.push({
+            name: "order_op_permission",
+            passed: false,
+            message: `Signer must have Order ${op.dispute.order} dispute operation permission`,
+        });
+    }
+    if (op.dispute && input.current_bPaused !== undefined) {
+        checks.push({
+            name: "arbitration_not_paused",
+            passed: !input.current_bPaused,
+            message: input.current_bPaused ? "Arbitration is paused — dispute will fail (E_PAUSED)" : "OK",
+        });
+    }
+    if (op.vote && input.current_timestamp_ms !== undefined && input.current_arb_status === "Voting") {
+        checks.push({
+            name: "voting_deadline_not_expired",
+            passed: true,
+            message: "Verify Arb.voting_deadline > current time (else vote rejected)",
+        });
+    }
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const ARBITRATION_CONFIRM_VERSION = "1.0.0";
+export function runArbitrationConfirmGate(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 && i.id !== "C-AB-11" && i.id !== "C-AB-12").map(i => i.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: ARBITRATION_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: ARBITRATION_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) {
+        if (input.arbitration_json.builder) {
+            const cab12 = checklist.items.find(i => i.id === "C-AB-12");
+            if (cab12) {
+                const qab5 = userConf.responses.find(r => r.question_id === "QAB5");
+                cab12.passed = qab5?.response === "yes";
+                cab12.message = cab12.passed ? "" : "Transfer not confirmed by user";
+            }
+        }
+        if (input.arbitration_json.builder) {
+            const cab12 = checklist.items.find(i => i.id === "C-AB-12");
+            if (cab12 && !cab12.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 ownership transfer",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: ARBITRATION_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: ARBITRATION_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: ARBITRATION_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.arbitration_json;
+    lines.push("═══ Arbitration Confirmation ═══");
+    lines.push("");
+    if (typeof data.object === "string") {
+        lines.push(`Arbitration: ${data.object}`);
+    }
+    else if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        lines.push(`Arbitration: NEW '${obj.name ?? "?"}' (T=${obj.type_parameter ?? "?"})`);
+    }
+    else {
+        lines.push("Arbitration: (not specified)");
+    }
+    if (data.description)
+        lines.push(`Description: ${data.description}`);
+    if (input.current_arb_status)
+        lines.push(`Current Arb status: ${input.current_arb_status}`);
+    if (input.expected_arb_status)
+        lines.push(`Expected Arb status: ${input.expected_arb_status}`);
+    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("");
+    }
+    lines.push("─ Operations ──────────────────");
+    if (data.dispute)
+        lines.push(`- DISPUTE on Order ${data.dispute.order} (${data.dispute.proposition.length} propositions)`);
+    if (data.confirm)
+        lines.push(`- CONFIRM Arb ${data.confirm.arb} (deadline=${data.confirm.voting_deadline ?? "none"})`);
+    if (data.vote)
+        lines.push(`- VOTE on Arb ${data.vote.arb} (${data.vote.voting_guard ? "weighted" : "open"})`);
+    if (data.feedback)
+        lines.push(`- FEEDBACK on Arb ${data.feedback.arb}`);
+    if (data.arbitration)
+        lines.push(`- ⚖️ RULING on Arb ${data.arbitration.arb} (indemnity=${data.arbitration.indemnity})`);
+    if (data.reset)
+        lines.push(`- ↻ RESET Arb ${data.reset.arb}`);
+    if (data.arb_withdraw)
+        lines.push(`- WITHDRAW from Arb ${data.arb_withdraw.arb}`);
+    if (data.fees_transfer) {
+        const dest = data.fees_transfer.to.allocation ? `Allocation ${data.fees_transfer.to.allocation}` : `Treasury ${data.fees_transfer.to.treasury}`;
+        lines.push(`- 💰 FEES → ${dest}`);
+    }
+    if (data.voting_guard)
+        lines.push(`- voting_guard ${data.voting_guard.op}`);
+    if (data.usage_guard !== undefined)
+        lines.push(`- usage_guard: ${data.usage_guard ?? "clear"}`);
+    if (data.builder)
+        lines.push(`- ⚠️ TRANSFER to: ${data.builder}`);
+    if (data.um !== undefined)
+        lines.push(`- UM: ${data.um ?? "(revoke)"}`);
+    lines.push("");
+    return lines.join("\n");
+}
+export function progressiveArbitrationCheck(input) {
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        return {
+            stage: "checklist",
+            status: "fail",
+            message: `Checklist failed: ${checklist.items.filter(i => !i.passed && i.id !== "C-AB-11" && i.id !== "C-AB-12").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/arbitration-context.d.ts

@@ -0,0 +1,81 @@
+import { type ArbitrationScene, type ArbitrationPermissionEntry, type ArbStatus, type DualGuardMatrix } from "./arbitration-ledger.js";
+import { type ArbitrationTemplate } from "./arbitration-templates.js";
+import { type SemanticToSchemaRule, type ArbitrationConstraintRule } from "./arbitration-translation.js";
+import { type RiskRule, type ArbitrationStakeholder, type ArbitrationRiskAssessment } from "./arbitration-risk.js";
+import { type ArbitrationPuzzle, type PuzzleCompleteness } from "./arbitration-puzzle.js";
+import { type ChecklistItem, type ConfirmationQuestion, type ArbitrationJsonForConfirm } from "./arbitration-confirm.js";
+export declare const ARBITRATION_CONTEXT_VERSION = "1.0.0";
+export type ArbitrationInjectionMode = "initial_design" | "mid_design_review" | "pre_publish" | "post_publish_modify" | "stakeholder_review" | "apply_check";
+export type ArbitrationStakeholderPerspective = ArbitrationStakeholder | "system";
+export interface ArbitrationContextBundle {
+    version: string;
+    mode: ArbitrationInjectionMode;
+    stakeholder_perspective?: ArbitrationStakeholderPerspective;
+    matched_scene?: ArbitrationScene;
+    matched_template?: ArbitrationTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: ArbitrationPuzzle;
+    puzzle_completeness?: PuzzleCompleteness;
+    relevant_risks: RiskRule[];
+    risk_assessment?: ArbitrationRiskAssessment;
+    relevant_checklist: ChecklistItem[];
+    relevant_questions: ConfirmationQuestion[];
+    relevant_permissions: ArbitrationPermissionEntry[];
+    relevant_constraints: ArbitrationConstraintRule[];
+    dual_guard_matrix_entry?: DualGuardMatrix;
+    arb_lifecycle_context?: ArbLifecycleContext;
+    cross_object_refs: ArbitrationCrossObjectRef[];
+    onchain_constraints: ArbitrationOnchainConstraint[];
+    rendering_hints: ArbitrationRenderingHints;
+}
+export interface ArbLifecycleContext {
+    current_status?: ArbStatus;
+    current_status_code?: number;
+    is_terminal: boolean;
+    valid_next_statuses: ArbStatus[];
+    valid_operations_from_here: string[];
+}
+export interface ArbitrationCrossObjectRef {
+    object: "Order" | "Service" | "Arb" | "Allocation" | "Treasury" | "Guard" | "Contact" | "Payment";
+    field: string;
+    scene_id: string;
+    description: string;
+    direction: "references" | "referenced_by";
+}
+export interface ArbitrationOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface ArbitrationRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_dual_guard_matrix: boolean;
+    include_arb_lifecycle: boolean;
+    include_immutability_warning: boolean;
+    include_indemnity_warning: boolean;
+    include_ownership_transfer_warning: boolean;
+    max_length: number;
+}
+export interface BuildArbitrationContextInput {
+    mode: ArbitrationInjectionMode;
+    intent?: string;
+    arbitration_json?: ArbitrationJsonForConfirm;
+    stakeholder?: ArbitrationStakeholderPerspective;
+    target_permission_index?: number;
+    target_operation_category?: ArbitrationScene["operation_category"];
+    current_arb_status?: ArbStatus;
+    voting_guard_empty?: boolean;
+    usage_guard_none?: boolean;
+    max_length?: number;
+}
+export declare function buildArbitrationContext(input: BuildArbitrationContextInput): ArbitrationContextBundle;
+export declare function buildPromptFromArbitrationContext(bundle: ArbitrationContextBundle): string;
+export declare function getArbitrationContextSummary(bundle: ArbitrationContextBundle): string;
+export { ARBITRATION_LEDGER_VERSION, ARBITRATION_SCENES, ARBITRATION_PERMISSIONS, DUAL_GUARD_MATRIX, ARB_STATUS_CODE, ARB_TERMINAL_STATUSES, findSceneById, findSceneByPermissionIndex, inferSceneFromIntent, getScenesByCategory, getDualGuardMatrixEntry, isValidArbStatusTransition, isTerminalArbStatus, getActiveArbitrationPermissions, getAllArbitrationPermissions, } from "./arbitration-ledger.js";
+export { ARBITRATION_TEMPLATES_VERSION, ARBITRATION_TEMPLATES, suggestTemplateForScene, getTemplatesByScene, getTemplateById, } from "./arbitration-templates.js";
+export { ARBITRATION_TRANSLATION_VERSION, SEMANTIC_TO_SCHEMA_RULES, ARBITRATION_CONSTRAINT_RULES, matchSemanticPattern, explainArbitrationCallData, explainPermissionIndex, explainArbStatus, } from "./arbitration-translation.js";
+export { ARBITRATION_RISK_VERSION, getAllRiskRules, assessArbitrationRisks, } from "./arbitration-risk.js";
+export { ARBITRATION_CONFIRM_VERSION, ARBITRATION_OPERATION_CHECKLIST, ARBITRATION_CONFIRMATION_QUESTIONS, runArbitrationConfirmGate, } from "./arbitration-confirm.js";
+export { initPuzzleFromIntent, checkPuzzleCompleteness, validateConstraints, } from "./arbitration-puzzle.js";