@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/treasury-confirm.js

@@ -0,0 +1,512 @@
+import { assessTreasuryRisks, } from "./treasury-risk.js";
+import { MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, MAX_EXTERNAL_WITHDRAW_GUARD_COUNT, MAX_DESCRIPTION_LENGTH, } from "./treasury-puzzle.js";
+export const TREASURY_PUBLISH_CHECKLIST = [
+    { id: "C-T-01", description: "type_parameter (Coin type T) specified and valid", passed: false, message: "" },
+    { id: "C-T-02", description: "Permission object configured (new or existing)", passed: false, message: "" },
+    { id: "C-T-03", description: "description length <= MAX_DESCRIPTION_LENGTH (4000)", passed: false, message: "" },
+    { id: "C-T-04", description: "external_withdraw_guard.identifier provided (u8, required)", passed: false, message: "" },
+    { id: "C-T-05", description: "external_deposit_guard count <= MAX_EXTERNAL_DEPOSIT_GUARD_COUNT (100)", passed: false, message: "" },
+    { id: "C-T-06", description: "external_withdraw_guard count <= MAX_EXTERNAL_WITHDRAW_GUARD_COUNT (200)", passed: false, message: "" },
+    { id: "C-T-07", description: "withdraw recipient address valid", passed: false, message: "" },
+    { id: "C-T-08", description: "UM address is valid Contact object reference (or null for revoke)", passed: false, message: "" },
+    { id: "C-T-09", description: "withdraw (fixed) / external_withdraw double-confirmed by user", passed: false, message: "" },
+    { id: "C-T-10", description: "Permission indexes align with Move on-chain (no stale 259/260)", passed: false, message: "" },
+];
+function runStaticChecklist(input) {
+    const items = TREASURY_PUBLISH_CHECKLIST.map(c => ({ ...c }));
+    const data = input.treasury_json;
+    const ct01 = items.find(i => i.id === "C-T-01");
+    if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        const valid = !!obj.type_parameter && obj.type_parameter.length > 0;
+        ct01.passed = valid;
+        ct01.message = valid ? "" : "type_parameter missing in object (required for creation)";
+    }
+    else if (input.type_parameter) {
+        ct01.passed = true;
+    }
+    else if (typeof data.object === "string") {
+        ct01.passed = true;
+    }
+    else {
+        ct01.passed = false;
+        ct01.message = "Cannot determine type_parameter";
+    }
+    const ct02 = items.find(i => i.id === "C-T-02");
+    if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        const valid = !!obj.permission;
+        ct02.passed = valid;
+        ct02.message = valid ? "" : "permission missing in object (required for creation)";
+    }
+    else if (input.permission_address) {
+        ct02.passed = true;
+    }
+    else {
+        ct02.passed = true;
+    }
+    const ct03 = items.find(i => i.id === "C-T-03");
+    if (data.description !== undefined) {
+        const valid = data.description.length <= MAX_DESCRIPTION_LENGTH;
+        ct03.passed = valid;
+        ct03.message = valid ? "" : `Description length ${data.description.length} > ${MAX_DESCRIPTION_LENGTH}`;
+    }
+    else {
+        ct03.passed = true;
+    }
+    const ct04 = items.find(i => i.id === "C-T-04");
+    if (data.external_withdraw_guard && (data.external_withdraw_guard.op === "add" || data.external_withdraw_guard.op === "set")) {
+        const missing = data.external_withdraw_guard.guards.filter(g => g.identifier === undefined || g.identifier === null);
+        const valid = missing.length === 0;
+        ct04.passed = valid;
+        ct04.message = valid ? "" : `${missing.length} withdraw guard(s) missing identifier (u8 required)`;
+    }
+    else {
+        ct04.passed = true;
+    }
+    const ct05 = items.find(i => i.id === "C-T-05");
+    if (data.external_deposit_guard && (data.external_deposit_guard.op === "add" || data.external_deposit_guard.op === "set")) {
+        const current = input.current_external_deposit_guard_count ?? 0;
+        const adding = data.external_deposit_guard.guards.length;
+        const valid = (data.external_deposit_guard.op === "set" ? adding : current + adding) <= MAX_EXTERNAL_DEPOSIT_GUARD_COUNT;
+        ct05.passed = valid;
+        ct05.message = valid ? "" : `deposit_guard count ${data.external_deposit_guard.op === "set" ? adding : current + adding} > ${MAX_EXTERNAL_DEPOSIT_GUARD_COUNT}`;
+    }
+    else {
+        ct05.passed = true;
+    }
+    const ct06 = items.find(i => i.id === "C-T-06");
+    if (data.external_withdraw_guard && (data.external_withdraw_guard.op === "add" || data.external_withdraw_guard.op === "set")) {
+        const current = input.current_external_withdraw_guard_count ?? 0;
+        const adding = data.external_withdraw_guard.guards.length;
+        const valid = (data.external_withdraw_guard.op === "set" ? adding : current + adding) <= MAX_EXTERNAL_WITHDRAW_GUARD_COUNT;
+        ct06.passed = valid;
+        ct06.message = valid ? "" : `withdraw_guard count ${data.external_withdraw_guard.op === "set" ? adding : current + adding} > ${MAX_EXTERNAL_WITHDRAW_GUARD_COUNT}`;
+    }
+    else {
+        ct06.passed = true;
+    }
+    const ct07 = items.find(i => i.id === "C-T-07");
+    if (data.withdraw?.recipient) {
+        const valid = data.withdraw.recipient.startsWith("0x") && data.withdraw.recipient.length >= 40;
+        ct07.passed = valid;
+        ct07.message = valid ? "" : `Recipient ${data.withdraw.recipient} invalid`;
+    }
+    else if (data.withdraw) {
+        ct07.passed = false;
+        ct07.message = "withdraw specified without recipient";
+    }
+    else {
+        ct07.passed = true;
+    }
+    const ct08 = items.find(i => i.id === "C-T-08");
+    if (data.um !== undefined) {
+        const valid = data.um === null || (typeof data.um === "string" && data.um.startsWith("0x") && data.um.length >= 40);
+        ct08.passed = valid;
+        ct08.message = valid ? "" : `UM ${data.um} invalid (must be Contact object address or null)`;
+    }
+    else {
+        ct08.passed = true;
+    }
+    const ct09 = items.find(i => i.id === "C-T-09");
+    if (data.withdraw) {
+        ct09.passed = false;
+        ct09.message = "Pending user confirmation in Layer 3 (QT3/QT4)";
+    }
+    else {
+        ct09.passed = true;
+    }
+    const ct10 = items.find(i => i.id === "C-T-10");
+    const staleIndexes = (input.current_permission_indexes_granted ?? []).filter(i => i === 259 || i === 260);
+    const valid = staleIndexes.length === 0;
+    ct10.passed = valid;
+    ct10.message = valid ? "" : `Stale indexes 259/260 detected: ${staleIndexes.join(",")} (R-T-01 regression)`;
+    return {
+        all_passed: items.filter(i => i.id !== "C-T-09").every(i => i.passed),
+        items,
+    };
+}
+function adaptRiskAssessment(input) {
+    const ctx = {
+        object: typeof input.treasury_json.object === "string" ? input.treasury_json.object : null,
+        description: input.treasury_json.description,
+        deposit: input.treasury_json.deposit ? {
+            coin_balance: input.treasury_json.deposit.coin?.balance,
+            coin_object: input.treasury_json.deposit.coin?.coin_object,
+            by_external_deposit_guard: input.treasury_json.deposit.by_external_deposit_guard,
+        } : undefined,
+        withdraw: input.treasury_json.withdraw ? {
+            amount_fixed: input.treasury_json.withdraw.amount?.fixed,
+            amount_by_external_withdraw_guard: input.treasury_json.withdraw.amount?.by_external_withdraw_guard,
+            recipient: input.treasury_json.withdraw.recipient,
+        } : undefined,
+        external_deposit_guard: input.treasury_json.external_deposit_guard,
+        external_withdraw_guard: input.treasury_json.external_withdraw_guard,
+        owner_receive: input.treasury_json.owner_receive,
+        um: input.treasury_json.um,
+        permission_address: input.permission_address,
+        type_parameter: input.type_parameter,
+        current_balance: input.current_balance,
+        current_external_deposit_guard_count: input.current_external_deposit_guard_count,
+        current_external_withdraw_guard_count: input.current_external_withdraw_guard_count,
+        shared_with_service: input.shared_with_service,
+        shared_with_allocator: input.shared_with_allocator,
+        shared_with_arbitration: input.shared_with_arbitration,
+        current_permission_indexes_granted: input.current_permission_indexes_granted,
+    };
+    return assessTreasuryRisks(ctx);
+}
+export const TREASURY_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QT1",
+        question: "Is the Coin type T (type_parameter) correct and matching all expected deposit/withdraw operations?",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QT2",
+        question: "Is the associated Permission object correctly configured with intended admin/entity/index assignments?",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QT3",
+        question: "⚠️ If withdrawing (fixed amount): do you confirm the recipient address and amount are correct? This operation is IRREVERSIBLE.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-T-4-01"],
+    },
+    {
+        id: "QT4",
+        question: "⚠️ If external_withdraw via Guard: do you confirm the Guard rules match business intent and the identifier points to the correct amount field? IRREVERSIBLE.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-T-4-02"],
+    },
+    {
+        id: "QT5",
+        question: "If configuring external_deposit/withdraw_guard: are the Guard table fields correctly typed (number for identifier, address-compatible for store_from_id)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-T-1-04"],
+    },
+    {
+        id: "QT6",
+        question: "If sharing Permission with a Service or referenced by Allocator/Arbitration: have you verified the cross-object consistency (R-T-5-01 / R-T-5-02)?",
+        requires_explicit_yes: false,
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const questions = [...TREASURY_CONFIRMATION_QUESTIONS];
+    if (!input.treasury_json.withdraw?.amount?.fixed) {
+        const idx = questions.findIndex(q => q.id === "QT3");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.treasury_json.withdraw?.amount?.by_external_withdraw_guard) {
+        const idx = questions.findIndex(q => q.id === "QT4");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.treasury_json.external_deposit_guard && !input.treasury_json.external_withdraw_guard) {
+        const idx = questions.findIndex(q => q.id === "QT5");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    if (!input.shared_with_service && !input.shared_with_allocator && !input.shared_with_arbitration) {
+        const idx = questions.findIndex(q => q.id === "QT6");
+        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.treasury_json.object === "string") {
+        checks.push({
+            name: "treasury_object_exists",
+            passed: true,
+            message: `Treasury object ${input.treasury_json.object} assumed to exist`,
+        });
+    }
+    if (input.permission_address || typeof input.treasury_json.object === "object") {
+        checks.push({
+            name: "permission_object_exists",
+            passed: true,
+            message: "Permission object exists and is bound to Treasury",
+        });
+    }
+    const requiredPerms = [];
+    if (input.treasury_json.deposit && !input.treasury_json.deposit.by_external_deposit_guard) {
+        requiredPerms.push(252);
+    }
+    if (input.treasury_json.withdraw?.amount?.fixed)
+        requiredPerms.push(254);
+    if (input.treasury_json.external_deposit_guard)
+        requiredPerms.push(255);
+    if (input.treasury_json.external_withdraw_guard)
+        requiredPerms.push(256);
+    if (input.treasury_json.owner_receive)
+        requiredPerms.push(257);
+    if (input.treasury_json.um !== undefined)
+        requiredPerms.push(258);
+    if (input.treasury_json.receive)
+        requiredPerms.push(253);
+    if (requiredPerms.length > 0) {
+        const granted = input.current_permission_indexes_granted ?? [];
+        const missing = requiredPerms.filter(p => !granted.includes(p));
+        checks.push({
+            name: "signer_has_required_permissions",
+            passed: missing.length === 0,
+            message: missing.length === 0
+                ? `Signer has all required indexes: ${requiredPerms.join(",")}`
+                : `Signer missing required indexes: ${missing.join(",")} (granted: ${granted.join(",")})`,
+        });
+    }
+    if (input.treasury_json.deposit?.by_external_deposit_guard ||
+        input.treasury_json.withdraw?.amount?.by_external_withdraw_guard) {
+        checks.push({
+            name: "passport_provided_for_external_ops",
+            passed: true,
+            message: "External operations require Passport submission (verified at SDK call time)",
+        });
+    }
+    if (input.treasury_json.withdraw?.amount?.fixed && input.current_balance) {
+        const amount = BigInt(input.treasury_json.withdraw.amount.fixed);
+        const balance = BigInt(input.current_balance);
+        const sufficient = amount <= balance;
+        checks.push({
+            name: "balance_sufficient_for_withdraw",
+            passed: sufficient,
+            message: sufficient
+                ? `Balance ${input.current_balance} >= withdraw ${input.treasury_json.withdraw.amount.fixed}`
+                : `Balance ${input.current_balance} < withdraw ${input.treasury_json.withdraw.amount.fixed} (E_WITHDRAW_INSUFFICIENT_AMOUNT)`,
+        });
+    }
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const TREASURY_CONFIRM_VERSION = "1.0.0";
+export function runTreasuryConfirmGate(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: TREASURY_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: TREASURY_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.treasury_json.withdraw) {
+            const ct09 = checklist.items.find(i => i.id === "C-T-09");
+            if (ct09) {
+                const qt3 = userConf.responses.find(r => r.question_id === "QT3");
+                const qt4 = userConf.responses.find(r => r.question_id === "QT4");
+                const relevantResponses = [qt3, qt4].filter(r => r !== undefined);
+                if (relevantResponses.length > 0) {
+                    ct09.passed = relevantResponses.every(r => r?.response === "yes");
+                    ct09.message = ct09.passed ? "" : "Withdraw not confirmed by user";
+                }
+            }
+        }
+        if (input.treasury_json.withdraw) {
+            const ct09 = checklist.items.find(i => i.id === "C-T-09");
+            if (ct09 && !ct09.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 withdraw operation",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: TREASURY_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: TREASURY_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: TREASURY_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.treasury_json;
+    lines.push("═══ Treasury Confirmation ═══");
+    lines.push("");
+    if (typeof data.object === "string") {
+        lines.push(`Treasury: ${data.object}`);
+    }
+    else if (typeof data.object === "object" && data.object !== null) {
+        const obj = data.object;
+        lines.push(`Treasury: NEW (name=${obj.name ?? "?"}, T=${obj.type_parameter ?? "?"})`);
+    }
+    else {
+        lines.push("Treasury: (invalid object field)");
+    }
+    if (data.description)
+        lines.push(`Description: ${data.description}`);
+    if (input.type_parameter)
+        lines.push(`Type parameter: ${input.type_parameter}`);
+    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.deposit) {
+        if (data.deposit.by_external_deposit_guard) {
+            lines.push(`- External deposit via guard: ${data.deposit.by_external_deposit_guard}`);
+        }
+        else {
+            lines.push(`- Internal deposit (Permission 252)`);
+        }
+    }
+    if (data.withdraw) {
+        if (data.withdraw.amount?.fixed) {
+            lines.push(`- ⚠️ Internal withdraw (Permission 254): ${data.withdraw.amount.fixed} to ${data.withdraw.recipient ?? "?"}`);
+        }
+        else if (data.withdraw.amount?.by_external_withdraw_guard) {
+            lines.push(`- ⚠️ External withdraw via guard: ${data.withdraw.amount.by_external_withdraw_guard} to ${data.withdraw.recipient ?? "?"}`);
+        }
+    }
+    if (data.receive)
+        lines.push(`- Receive CoinWrapper (Permission 253)`);
+    if (data.owner_receive)
+        lines.push(`- owner_receive forward (Permission 257)`);
+    if (data.external_deposit_guard)
+        lines.push(`- Manage external_deposit_guard (Permission 255): op=${data.external_deposit_guard.op}`);
+    if (data.external_withdraw_guard)
+        lines.push(`- Manage external_withdraw_guard (Permission 256): op=${data.external_withdraw_guard.op}`);
+    if (data.um !== undefined)
+        lines.push(`- UM: ${data.um ?? "(revoke)"}`);
+    lines.push("");
+    return lines.join("\n");
+}
+export function progressiveTreasuryCheck(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 (especially withdraw irreversibility)",
+        };
+    }
+    if (assessment.needs_human_review) {
+        return {
+            stage: "confirmation",
+            status: "pending",
+            message: "Human review required for HIGH risks (withdraw/external operations)",
+            next_action: "Confirm risk acceptance via QT1-QT6 questions",
+        };
+    }
+    return {
+        stage: "complete",
+        status: "pass",
+        message: "All checks passed",
+    };
+}

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

@@ -0,0 +1,64 @@
+import { type TreasuryScene, type BuiltinTreasuryPermissionEntry } from "./treasury-ledger.js";
+import { type TreasuryTemplate } from "./treasury-templates.js";
+import { type SemanticToSchemaRule } from "./treasury-translation.js";
+import { type TreasuryRiskRule, type TreasuryRiskAssessment, type TreasuryStakeholder } from "./treasury-risk.js";
+import { type TreasuryPuzzle, type TreasuryPuzzleCompleteness } from "./treasury-puzzle.js";
+import { TREASURY_PUBLISH_CHECKLIST, TREASURY_CONFIRMATION_QUESTIONS, type TreasuryJsonForConfirm } from "./treasury-confirm.js";
+export declare const TREASURY_CONTEXT_VERSION = "1.0.0";
+export type TreasuryInjectionMode = "initial_design" | "mid_design_review" | "pre_publish" | "post_publish_modify" | "stakeholder_review" | "cross_object_check";
+export type TreasuryStakeholderPerspective = TreasuryStakeholder | "system";
+export interface TreasuryContextBundle {
+    version: string;
+    mode: TreasuryInjectionMode;
+    stakeholder_perspective?: TreasuryStakeholderPerspective;
+    matched_scene?: TreasuryScene;
+    matched_template?: TreasuryTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: TreasuryPuzzle;
+    puzzle_completeness?: TreasuryPuzzleCompleteness;
+    relevant_risks: TreasuryRiskRule[];
+    risk_assessment?: TreasuryRiskAssessment;
+    relevant_checklist: typeof TREASURY_PUBLISH_CHECKLIST;
+    relevant_questions: typeof TREASURY_CONFIRMATION_QUESTIONS;
+    relevant_builtin_permissions: BuiltinTreasuryPermissionEntry[];
+    reserved_builtin_permissions: BuiltinTreasuryPermissionEntry[];
+    cross_object_refs: TreasuryCrossObjectRef[];
+    onchain_constraints: TreasuryOnchainConstraint[];
+    rendering_hints: TreasuryRenderingHints;
+}
+export interface TreasuryCrossObjectRef {
+    object: "Permission" | "Guard" | "Passport" | "Payment" | "CoinWrapper" | "Contact" | "Allocator" | "Arbitration" | "Service" | "Registrar" | "Clock";
+    field: string;
+    description: string;
+    collaboration_type: "dependency" | "referenced_by" | "parallel_design";
+}
+export interface TreasuryOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface TreasuryRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_irreversibility_warning: boolean;
+    include_external_guard_warning: boolean;
+    include_cross_object_warning: boolean;
+    max_length: number;
+}
+export interface BuildTreasuryContextInput {
+    mode: TreasuryInjectionMode;
+    intent?: string;
+    treasury_json?: TreasuryJsonForConfirm;
+    stakeholder?: TreasuryStakeholderPerspective;
+    target_permission_index?: number;
+    type_parameter?: string;
+    max_length?: number;
+    shared_with_service?: boolean;
+    shared_with_allocator?: boolean;
+    shared_with_arbitration?: boolean;
+    current_permission_indexes_granted?: number[];
+}
+export declare function buildTreasuryContext(input: BuildTreasuryContextInput): TreasuryContextBundle;
+export declare function buildPromptFromTreasuryContext(bundle: TreasuryContextBundle): string;
+export declare function getTreasuryContextSummary(bundle: TreasuryContextBundle): string;