@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/treasury-ledger.js

@@ -0,0 +1,300 @@
+export const TREASURY_PERMISSIONS = [
+    { index: 250, name: "TREASURY_NEW", description: "Create new Treasury", governed_operation: "treasury::new", active: true },
+    { index: 251, name: "TREASURY_DESCRIPTION", description: "Modify Treasury description", governed_operation: "treasury::description_set", active: true },
+    { index: 252, name: "TREASURY_DEPOSIT", description: "Internal deposit (Permission path)", governed_operation: "treasury::deposit", active: true },
+    { index: 253, name: "TREASURY_RECEIVE", description: "Receive CoinWrapper into balance", governed_operation: "treasury::receive", active: true },
+    { index: 254, name: "TREASURY_WITHDRAW", description: "Internal withdraw (Permission path, fixed amount)", governed_operation: "treasury::withdraw", active: true },
+    { index: 255, name: "TREASURY_EXTERNAL_DEPOSIT_GUARD", description: "Manage external deposit Guard list (add/remove/clear)", governed_operation: "treasury::external_deposit_guard_add/remove/clear", active: true },
+    { index: 256, name: "TREASURY_EXTERNAL_WITHDRAW_GUARD", description: "Manage external withdraw Guard list (add/remove/clear)", governed_operation: "treasury::external_withdraw_guard_add/remove/clear", active: true },
+    { index: 257, name: "TREASURY_OWNER_RECEIVE", description: "Owner receive (unwrap received objects, send to Permission owner)", governed_operation: "treasury::owner_receive / owner_receive_object", active: true },
+    { index: 258, name: "TREASURY_UM", description: "Set UM (User Manager = Contact object)", governed_operation: "treasury::um_set / um_none", active: true },
+    { index: -1, name: "TREASURY_EXTERNAL_DEPOSIT_RESERVED", description: "RESERVED — external_deposit uses Guard + Passport, does NOT call permission::check", governed_operation: "treasury::external_deposit (Guard path)", active: false },
+    { index: -1, name: "TREASURY_EXTERNAL_WITHDRAW_RESERVED", description: "RESERVED — external_withdraw uses Guard + Passport, does NOT call permission::check", governed_operation: "treasury::external_withdraw (Guard path)", active: false },
+];
+export const TREASURY_SCENES = [
+    {
+        id: "treasury_fund_collection",
+        name: "Team fund collection (internal deposit + receive)",
+        coin_type_category: "generic",
+        permission_index_range: "250-254",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => [250, 251, 252, 253, 254].includes(p.index)),
+        owner_operations: ["um_set (258)", "owner_receive (257)", "permission transfer"],
+        admin_operations: ["description_set (251)"],
+        permission_index_operations: [
+            "treasury::deposit (252)",
+            "treasury::receive (253)",
+        ],
+        external_operations: [],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Owner-only deposit: TREASURY_DEPOSIT (252) granted to team finance",
+            "Receive automation: TREASURY_RECEIVE (253) for CoinWrapper intake",
+            "No external Guard: all deposits via Permission path",
+            "inflow accumulates total team contributions",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Allocator.sharing.who=Entity → Treasury address (fund inflow)",
+            "Treasury.receive (253) converts CoinWrapper to balance",
+        ],
+        recommended_templates: ["T-T-01", "T-T-06"],
+    },
+    {
+        id: "treasury_external_ops",
+        name: "External deposit / withdraw with Guard protection",
+        coin_type_category: "generic",
+        permission_index_range: "255-256",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => [255, 256].includes(p.index)),
+        owner_operations: ["external_deposit_guard_add/remove/clear (255)", "external_withdraw_guard_add/remove/clear (256)"],
+        admin_operations: [],
+        permission_index_operations: [
+            "treasury::external_deposit_guard_* (255)",
+            "treasury::external_withdraw_guard_* (256)",
+        ],
+        external_operations: [
+            "treasury::external_deposit (Guard + Passport, no Permission)",
+            "treasury::external_withdraw (Guard + Passport, no Permission)",
+        ],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Whitelist external deposit: external_deposit_guard with identifier=None",
+            "Capped external withdraw: external_withdraw_guard with identifier=amount field",
+            "Pair external ops with Guard for zero-Permission external access",
+            "store_from_id tracks order/business ID for audit trail",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Guard object referenced by external_deposit_guard / external_withdraw_guard",
+            "Passport object required for every external_deposit / external_withdraw call",
+        ],
+        recommended_templates: ["T-T-03", "T-T-04"],
+    },
+    {
+        id: "treasury_guard_protection",
+        name: "Guard-protected Treasury (asymmetric identifier design)",
+        coin_type_category: "generic",
+        permission_index_range: "255-256",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => [255, 256].includes(p.index)),
+        owner_operations: ["external_deposit_guard management (255)", "external_withdraw_guard management (256)"],
+        admin_operations: [],
+        permission_index_operations: [
+            "treasury::external_deposit_guard_add (255)",
+            "treasury::external_withdraw_guard_add (256)",
+        ],
+        external_operations: [
+            "external_deposit via Guard (identifier: Option<u8> — None means no amount limit)",
+            "external_withdraw via Guard (identifier: u8 — REQUIRED, no None option)",
+        ],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Asymmetric identifier: deposit optional, withdraw required",
+            "Deposit amount from Coin itself; withdraw amount from Guard submission",
+            "upsert semantics: add updates existing guard, else appends",
+            "external_deposit splits coin if value > guard-specified amount",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Guard table item value type must be number (is_number_type) for identifier",
+            "Guard table item value type must be address-compatible for store_from_id",
+        ],
+        recommended_templates: ["T-T-03"],
+    },
+    {
+        id: "treasury_permission_sharing",
+        name: "Treasury shared with Service via common Permission",
+        coin_type_category: "generic",
+        permission_index_range: "250-258",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => p.active),
+        owner_operations: ["um_set (258)", "owner_receive (257)"],
+        admin_operations: ["description_set (251)"],
+        permission_index_operations: [
+            "treasury::deposit (252) + service::publish (311) on same Permission",
+            "treasury::withdraw (254) + service::compensation_fund_withdraw (315)",
+        ],
+        external_operations: [],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Shared Permission: Treasury + Service reference same Permission object",
+            "Unified admin list: single admin team manages both Service and Treasury",
+            "Simplifies key management: one Permission object per business unit",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Service.compensation_fund (parallel design, NOT a Treasury)",
+            "Service.order_allocator → Treasury as Entity target",
+        ],
+        recommended_templates: ["T-T-04", "T-T-05"],
+    },
+    {
+        id: "treasury_um_delegation",
+        name: "UM delegation (User Manager = Contact object)",
+        coin_type_category: "generic",
+        permission_index_range: "258",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => p.index === 258),
+        owner_operations: ["um_set (258)", "um_none (258)"],
+        admin_operations: [],
+        permission_index_operations: [
+            "treasury::um_set (258)",
+            "treasury::um_none (258)",
+        ],
+        external_operations: [],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Owner-only UM: TREASURY_UM (258) restricted to owner (assert_owner)",
+            "UM is a Contact object address, not a regular user address",
+            "UM ≠ admin: UM is for contact management, not permission management",
+            "um_none revokes UM and disaffiliates from Registrar",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Contact object referenced by Treasury.um",
+            "Registrar.affiliation / disaffiliation tracks UM-Treasury binding",
+        ],
+        recommended_templates: ["T-T-01"],
+    },
+    {
+        id: "treasury_owner_receive",
+        name: "Owner receive (unwrap & forward to Permission owner)",
+        coin_type_category: "generic",
+        permission_index_range: "257",
+        builtin_indexes: TREASURY_PERMISSIONS.filter(p => p.index === 257),
+        owner_operations: ["owner_receive (257)", "owner_receive_object (257)"],
+        admin_operations: [],
+        permission_index_operations: [
+            "treasury::owner_receive (257)",
+            "treasury::owner_receive_object (257)",
+        ],
+        external_operations: [],
+        guard_list_mutable_after_publish: true,
+        common_patterns: [
+            "Forward received assets: CoinWrapper unwrapped, sent to Permission.owner",
+            "Does NOT write to history (direct forward, no Record entry)",
+            "Used when Treasury should not retain received assets",
+            "owner_receive_object handles non-coin objects too",
+        ],
+        irreversibility: {
+            deposit: "reversible",
+            withdraw: "irreversible",
+            external_deposit: "reversible",
+            external_withdraw: "irreversible",
+            owner_receive: "irreversible",
+        },
+        cross_object_collaboration: [
+            "Permission.owner is the recipient (resolved at tx time)",
+            "Received objects come from Allocator / Arbitration.fees_transfer / external deposits",
+        ],
+        recommended_templates: ["T-T-06"],
+    },
+];
+export const TREASURY_LEDGER_VERSION = "1.0.0";
+export function getScenesByHostObject(_host) {
+    return TREASURY_SCENES;
+}
+export function findSceneById(id) {
+    return TREASURY_SCENES.find(s => s.id === id);
+}
+export function findSceneByPermissionIndex(index) {
+    for (const scene of TREASURY_SCENES) {
+        if (scene.builtin_indexes.some(p => p.index === index && p.active))
+            return scene;
+    }
+    return undefined;
+}
+export function getBuiltinPermissionByIndex(index) {
+    return TREASURY_PERMISSIONS.find(p => p.index === index && p.active);
+}
+export function isBuiltinTreasuryPermission(index) {
+    return getBuiltinPermissionByIndex(index) !== undefined;
+}
+export function getActiveBuiltinPermissions() {
+    return TREASURY_PERMISSIONS.filter(p => p.active);
+}
+export function getReservedBuiltinPermissions() {
+    return TREASURY_PERMISSIONS.filter(p => !p.active);
+}
+export function inferSceneFromIntent(intent) {
+    const lower = intent.toLowerCase();
+    if (lower.includes("um") || lower.includes("delegate") || lower.includes("user manager")) {
+        return findSceneById("treasury_um_delegation");
+    }
+    if (lower.includes("owner_receive") || lower.includes("owner receive") || lower.includes("forward")) {
+        return findSceneById("treasury_owner_receive");
+    }
+    if (lower.includes("external") || lower.includes("guard")) {
+        if (lower.includes("deposit")) {
+            return findSceneById("treasury_external_ops");
+        }
+        if (lower.includes("withdraw")) {
+            return findSceneById("treasury_external_ops");
+        }
+        return findSceneById("treasury_guard_protection");
+    }
+    if (lower.includes("service") || lower.includes("share")) {
+        return findSceneById("treasury_permission_sharing");
+    }
+    if (lower.includes("deposit") || lower.includes("receive") || lower.includes("fund") || lower.includes("collect")) {
+        return findSceneById("treasury_fund_collection");
+    }
+    return undefined;
+}
+export function getTreasuryScenesCount() {
+    return TREASURY_SCENES.length;
+}
+export function getMoveFunctionsForPermissionIndex(index) {
+    const map = {
+        250: ["treasury::new", "treasury::new_with_passport"],
+        251: ["treasury::description_set", "treasury::description_set_with_passport"],
+        252: ["treasury::deposit", "treasury::deposit_with_passport"],
+        253: ["treasury::receive", "treasury::receive_with_passport"],
+        254: ["treasury::withdraw", "treasury::withdraw_with_passport"],
+        255: [
+            "treasury::external_deposit_guard_add",
+            "treasury::external_deposit_guard_add_with_passport",
+            "treasury::external_deposit_guard_remove",
+            "treasury::external_deposit_guard_remove_with_passport",
+            "treasury::external_deposit_guard_clear",
+            "treasury::external_deposit_guard_clear_with_passport",
+        ],
+        256: [
+            "treasury::external_withdraw_guard_add",
+            "treasury::external_withdraw_guard_add_with_passport",
+            "treasury::external_withdraw_guard_remove",
+            "treasury::external_withdraw_guard_remove_with_passport",
+            "treasury::external_withdraw_guard_clear",
+            "treasury::external_withdraw_guard_clear_with_passport",
+        ],
+        257: ["treasury::owner_receive", "treasury::owner_receive_object"],
+        258: ["treasury::um_set", "treasury::um_set_with_passport", "treasury::um_none", "treasury::um_none_with_passport"],
+    };
+    return map[index] ?? [];
+}

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

@@ -0,0 +1,163 @@
+export interface TreasuryIntentPuzzle {
+    action: "create" | "deposit" | "withdraw" | "external_deposit" | "external_withdraw" | "receive" | "owner_receive" | "manage_guard" | "set_um" | "set_description";
+    coin_type?: string;
+    purpose: "team_fund" | "compensation_lock" | "revenue_collection" | "project_budget" | "customer_service_pool" | "fee_sink" | "refund_pool" | "custom";
+    rule_sentence: string;
+    failure_conditions: string[];
+}
+export interface TreasuryBindingPuzzle {
+    host_object: "Treasury";
+    type_parameter: string;
+    associated_permission: string;
+    associated_um?: string | null;
+    sharing_with_allocator: boolean;
+    sharing_with_arbitration: boolean;
+    sharing_with_service: boolean;
+}
+export interface TreasuryDataSourcePuzzle {
+    permission_object: string;
+    coin_source: {
+        type: "balance";
+        value: string;
+    } | {
+        type: "coin_object";
+        address: string;
+    } | {
+        type: "received";
+        received_objects: string[];
+    };
+    external_deposit_guards: AmountFromDepositGuardPuzzle[];
+    external_withdraw_guards: AmountFromWithdrawGuardPuzzle[];
+    passport_submissions?: {
+        guard_address: string;
+        identifier: number;
+        value_type: "number" | "address";
+        value: string | number;
+    }[];
+}
+export interface AmountFromDepositGuardPuzzle {
+    guard: string;
+    identifier?: number | null;
+    store_from_id?: number | null;
+}
+export interface AmountFromWithdrawGuardPuzzle {
+    guard: string;
+    identifier: number;
+    store_from_id?: number | null;
+}
+export type TreasuryOperation = {
+    type: "deposit";
+    coin: {
+        balance: string;
+    } | {
+        coin_object: string;
+    };
+    via: "permission" | "external_guard";
+    guard?: string;
+    payment_info: {
+        remark?: string;
+        index: number;
+    };
+} | {
+    type: "withdraw";
+    amount: {
+        fixed: string;
+    } | {
+        by_external_withdraw_guard: string;
+    };
+    recipient: string;
+    payment_info: {
+        remark?: string;
+        index: number;
+    };
+} | {
+    type: "receive";
+    received: string[] | "recently";
+} | {
+    type: "owner_receive";
+    received: string[] | "recently";
+} | {
+    type: "external_deposit_guard_op";
+    op: "add" | "set" | "remove" | "clear";
+    guards?: AmountFromDepositGuardPuzzle[] | string[];
+} | {
+    type: "external_withdraw_guard_op";
+    op: "add" | "set" | "remove" | "clear";
+    guards?: AmountFromWithdrawGuardPuzzle[] | string[];
+} | {
+    type: "description_set";
+    description: string;
+} | {
+    type: "um_set";
+    um: string | null;
+};
+export interface TreasuryOperationPuzzle {
+    operations: TreasuryOperation[];
+}
+export interface TreasuryLogicPuzzle {
+    access_control_flow: {
+        path: "permission" | "external_guard" | "owner_receive";
+        permission_index?: number;
+        guard_address?: string;
+        passport_required: boolean;
+    }[];
+    fund_flow: {
+        from: "caller" | "balance" | "received";
+        to: "balance" | "recipient" | "permission_owner";
+        amount_source: "fixed" | "guard_identifier" | "coin_value" | "received_value";
+    }[];
+    history_record: {
+        op: "Withdraw" | "Deposit" | "Receive";
+        signer: string;
+        external_guard: string | null;
+        store_from_id: string | null;
+    }[];
+}
+export interface TreasuryConstraintChecklist {
+    F_T_01_description_length_le_4000: boolean;
+    F_T_02_external_deposit_guard_count_le_100: boolean;
+    F_T_03_external_withdraw_guard_count_le_200: boolean;
+    F_T_04_external_withdraw_guard_identifier_required: boolean;
+    F_T_05_guard_identifier_is_number_type: boolean;
+    F_T_06_store_from_id_address_compatible: boolean;
+    F_T_07_external_deposit_amount_sufficient: boolean;
+    F_T_08_external_withdraw_amount_le_balance: boolean;
+    F_T_09_withdraw_fixed_amount_le_balance: boolean;
+    F_T_10_external_guard_in_list: boolean;
+    F_T_11_coin_type_matches_type_parameter: boolean;
+    F_T_12_um_is_contact_object: boolean;
+    F_T_13_permission_index_matches_move: boolean;
+}
+export type TreasuryPuzzleDimension = "A" | "B" | "C" | "D" | "E" | "F";
+export interface TreasuryPuzzle {
+    intent?: TreasuryIntentPuzzle;
+    binding?: TreasuryBindingPuzzle;
+    data_source?: TreasuryDataSourcePuzzle;
+    operations?: TreasuryOperationPuzzle;
+    logic?: TreasuryLogicPuzzle;
+    constraints?: TreasuryConstraintChecklist;
+}
+export interface TreasuryPuzzleCompleteness {
+    dimensions: TreasuryPuzzleDimension[];
+    missing: TreasuryPuzzleDimension[];
+    missing_details: {
+        dimension: TreasuryPuzzleDimension;
+        reason: string;
+    }[];
+    complete: boolean;
+    next_step: string;
+}
+export declare function initPuzzleFromIntent(intent: Partial<TreasuryIntentPuzzle>): TreasuryPuzzle;
+export declare function checkPuzzleCompleteness(puzzle: TreasuryPuzzle): TreasuryPuzzleCompleteness;
+export interface TreasuryConstraintViolation {
+    constraint_id: string;
+    severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+    message: string;
+    current_value?: string | number;
+    limit?: string | number;
+}
+export declare const MAX_EXTERNAL_DEPOSIT_GUARD_COUNT = 100;
+export declare const MAX_EXTERNAL_WITHDRAW_GUARD_COUNT = 200;
+export declare const MAX_DESCRIPTION_LENGTH = 4000;
+export declare function validateConstraints(puzzle: TreasuryPuzzle): TreasuryConstraintViolation[];
+export declare function generateConfirmationText(puzzle: TreasuryPuzzle): string;

package/dist/knowledge/treasury-puzzle.js

@@ -0,0 +1,216 @@
+export function initPuzzleFromIntent(intent) {
+    const puzzle = {};
+    if (intent.action || intent.rule_sentence) {
+        puzzle.intent = {
+            action: intent.action ?? "create",
+            coin_type: intent.coin_type,
+            purpose: intent.purpose ?? "custom",
+            rule_sentence: intent.rule_sentence ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        };
+    }
+    puzzle.constraints = {
+        F_T_01_description_length_le_4000: true,
+        F_T_02_external_deposit_guard_count_le_100: true,
+        F_T_03_external_withdraw_guard_count_le_200: true,
+        F_T_04_external_withdraw_guard_identifier_required: true,
+        F_T_05_guard_identifier_is_number_type: true,
+        F_T_06_store_from_id_address_compatible: true,
+        F_T_07_external_deposit_amount_sufficient: true,
+        F_T_08_external_withdraw_amount_le_balance: true,
+        F_T_09_withdraw_fixed_amount_le_balance: true,
+        F_T_10_external_guard_in_list: true,
+        F_T_11_coin_type_matches_type_parameter: true,
+        F_T_12_um_is_contact_object: true,
+        F_T_13_permission_index_matches_move: 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) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "Binding not specified (type_parameter + permission)" });
+    }
+    else if (!puzzle.binding.type_parameter) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "type_parameter (Coin type T) missing" });
+    }
+    else if (!puzzle.binding.associated_permission) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "associated_permission missing" });
+    }
+    if (!puzzle.data_source && puzzle.intent?.action === "create") {
+        missing.push("C");
+        missing_details.push({ dimension: "C", reason: "Data source not specified (permission + coin_source + guards)" });
+    }
+    if (!puzzle.operations) {
+        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 (access_control + fund_flow + history) not defined" });
+    }
+    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 const MAX_EXTERNAL_DEPOSIT_GUARD_COUNT = 100;
+export const MAX_EXTERNAL_WITHDRAW_GUARD_COUNT = 200;
+export const MAX_DESCRIPTION_LENGTH = 4000;
+export function validateConstraints(puzzle) {
+    const violations = [];
+    if (puzzle.operations?.operations) {
+        for (const op of puzzle.operations.operations) {
+            if (op.type === "description_set" && op.description.length > MAX_DESCRIPTION_LENGTH) {
+                violations.push({
+                    constraint_id: "F-T-01",
+                    severity: "HIGH",
+                    message: `Description length ${op.description.length} exceeds MAX_DESCRIPTION_LENGTH ${MAX_DESCRIPTION_LENGTH}`,
+                    current_value: op.description.length,
+                    limit: MAX_DESCRIPTION_LENGTH,
+                });
+            }
+        }
+    }
+    if (puzzle.data_source && puzzle.data_source.external_deposit_guards.length > MAX_EXTERNAL_DEPOSIT_GUARD_COUNT) {
+        violations.push({
+            constraint_id: "F-T-02",
+            severity: "HIGH",
+            message: `external_deposit_guard count ${puzzle.data_source.external_deposit_guards.length} exceeds ${MAX_EXTERNAL_DEPOSIT_GUARD_COUNT}`,
+            current_value: puzzle.data_source.external_deposit_guards.length,
+            limit: MAX_EXTERNAL_DEPOSIT_GUARD_COUNT,
+        });
+    }
+    if (puzzle.data_source && puzzle.data_source.external_withdraw_guards.length > MAX_EXTERNAL_WITHDRAW_GUARD_COUNT) {
+        violations.push({
+            constraint_id: "F-T-03",
+            severity: "HIGH",
+            message: `external_withdraw_guard count ${puzzle.data_source.external_withdraw_guards.length} exceeds ${MAX_EXTERNAL_WITHDRAW_GUARD_COUNT}`,
+            current_value: puzzle.data_source.external_withdraw_guards.length,
+            limit: MAX_EXTERNAL_WITHDRAW_GUARD_COUNT,
+        });
+    }
+    if (puzzle.data_source) {
+        for (const g of puzzle.data_source.external_withdraw_guards) {
+            if (g.identifier === undefined || g.identifier === null) {
+                violations.push({
+                    constraint_id: "F-T-04",
+                    severity: "HIGH",
+                    message: `external_withdraw_guard ${g.guard} missing required identifier (u8)`,
+                });
+            }
+        }
+    }
+    if (puzzle.logic?.access_control_flow) {
+        for (const flow of puzzle.logic.access_control_flow) {
+            if (flow.permission_index !== undefined) {
+                if (flow.permission_index > 258 && flow.permission_index < 1000) {
+                    violations.push({
+                        constraint_id: "F-T-13",
+                        severity: "CRITICAL",
+                        message: `Permission index ${flow.permission_index} is in the 259-999 range; active Treasury indexes are 250-258. Possible R-T-01 residual.`,
+                        current_value: flow.permission_index,
+                        limit: "250-258",
+                    });
+                }
+            }
+        }
+    }
+    return violations;
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [];
+    lines.push("═══ Treasury Confirmation ═══");
+    lines.push("");
+    if (puzzle.intent) {
+        lines.push(`Action: ${puzzle.intent.action}`);
+        if (puzzle.intent.coin_type)
+            lines.push(`Coin type: ${puzzle.intent.coin_type}`);
+        lines.push(`Purpose: ${puzzle.intent.purpose}`);
+        lines.push(`Rule: ${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) {
+        lines.push("─ Binding ──────────────");
+        lines.push(`Host object: ${puzzle.binding.host_object}`);
+        lines.push(`Type parameter (T): ${puzzle.binding.type_parameter}`);
+        lines.push(`Associated Permission: ${puzzle.binding.associated_permission}`);
+        if (puzzle.binding.associated_um !== undefined) {
+            lines.push(`UM: ${puzzle.binding.associated_um ?? "(none)"}`);
+        }
+        lines.push(`Sharing with Allocator: ${puzzle.binding.sharing_with_allocator}`);
+        lines.push(`Sharing with Arbitration: ${puzzle.binding.sharing_with_arbitration}`);
+        lines.push(`Sharing with Service: ${puzzle.binding.sharing_with_service}`);
+        lines.push("");
+    }
+    if (puzzle.data_source) {
+        lines.push("─ Data Source ──────────────");
+        lines.push(`Permission: ${puzzle.data_source.permission_object}`);
+        lines.push(`Coin source: ${JSON.stringify(puzzle.data_source.coin_source)}`);
+        if (puzzle.data_source.external_deposit_guards.length > 0) {
+            lines.push(`External deposit guards (${puzzle.data_source.external_deposit_guards.length}):`);
+            for (const g of puzzle.data_source.external_deposit_guards) {
+                lines.push(`  guard=${g.guard}, identifier=${g.identifier ?? "None"}, store_from_id=${g.store_from_id ?? "None"}`);
+            }
+        }
+        if (puzzle.data_source.external_withdraw_guards.length > 0) {
+            lines.push(`External withdraw guards (${puzzle.data_source.external_withdraw_guards.length}):`);
+            for (const g of puzzle.data_source.external_withdraw_guards) {
+                lines.push(`  guard=${g.guard}, identifier=${g.identifier} (required), store_from_id=${g.store_from_id ?? "None"}`);
+            }
+        }
+        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("Access control flow:");
+        for (const f of puzzle.logic.access_control_flow) {
+            lines.push(`  path=${f.path}, perm_idx=${f.permission_index ?? "N/A"}, guard=${f.guard_address ?? "N/A"}, passport=${f.passport_required}`);
+        }
+        lines.push("Fund flow:");
+        for (const f of puzzle.logic.fund_flow) {
+            lines.push(`  from=${f.from}, to=${f.to}, amount_source=${f.amount_source}`);
+        }
+        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");
+}