@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/allocation-confirm.js

@@ -0,0 +1,534 @@
+import { MAX_ALLOCATOR_COUNT, ALLOCATION_MAX_SHARING_COUNT, RATE_TOTAL_FULL, ALLOCATION_ERROR_CODES, isSignerRecipient, isEntityRecipient, } from "./allocation-ledger.js";
+import { assessAllocationRisks, } from "./allocation-risk.js";
+export const ALLOCATION_PUBLISH_CHECKLIST = [
+    { id: "C-A-01", description: "Allocator count <= MAX_ALLOCATOR_COUNT (100)", passed: false, message: "" },
+    { id: "C-A-02", description: "Sharing count per Allocator <= MAX_SHARING_COUNT (100)", passed: false, message: "" },
+    { id: "C-A-03", description: "At most 1 Surplus sharing per Allocator (EMULTIPLE_SURPLUS)", passed: false, message: "" },
+    { id: "C-A-04", description: "Pure Rate mode sum(rates) == 10000 (ERATE_NOT_10000) OR Rate+Surplus sum <= 10000 (ERATE_EXCEEDS_10000)", passed: false, message: "" },
+    { id: "C-A-05", description: "Pure Amount mode sum(fix) >= threshold (EAMOUNT_BELOW_THRESHOLD)", passed: false, message: "" },
+    { id: "C-A-06", description: "Amount sum(fix) <= max when max is set (EAMOUNT_EXCEEDS_MAX)", passed: false, message: "" },
+    { id: "C-A-07", description: "allocators[].guard unique within the same Allocators (F-A-14)", passed: false, message: "" },
+    { id: "C-A-08", description: "Guard addresses valid (0x prefix, length >= 40)", passed: false, message: "" },
+    { id: "C-A-09", description: "Entity addresses valid (0x prefix, length >= 40)", passed: false, message: "" },
+    { id: "C-A-10", description: "Signer recipients have Guard Signer binding (R-A-2-01 CRITICAL theft risk)", passed: false, message: "" },
+    { id: "C-A-11", description: "payment_info present (required at alloc() time — ENO_PAYMENT_INFO)", passed: false, message: "" },
+    { id: "C-A-12", description: "coin type matches type_parameter (EINSUFFICIENT_BALANCE if mismatch)", passed: false, message: "" },
+];
+function isValidAddress(s) {
+    return typeof s === "string" && s.startsWith("0x") && s.length >= 40;
+}
+function runStaticChecklist(input) {
+    const items = ALLOCATION_PUBLISH_CHECKLIST.map(c => ({ ...c }));
+    const data = input.allocation_json;
+    const isCreate = data.object !== null &&
+        data.object !== undefined &&
+        typeof data.object === "object" &&
+        !Array.isArray(data.object);
+    if (!isCreate) {
+        for (const item of items)
+            item.passed = true;
+        if (typeof data.object === "string") {
+            const objValid = isValidAddress(data.object);
+            items.find(i => i.id === "C-A-08").passed = objValid;
+            items.find(i => i.id === "C-A-08").message = objValid ? "" : `Allocation object address ${data.object} invalid`;
+        }
+        if (data.alloc_by_guard !== undefined) {
+            const guardValid = isValidAddress(data.alloc_by_guard);
+            items.find(i => i.id === "C-A-09").passed = guardValid;
+            items.find(i => i.id === "C-A-09").message = guardValid ? "" : `alloc_by_guard address ${data.alloc_by_guard} invalid`;
+        }
+        return { all_passed: items.every(i => i.passed), items };
+    }
+    const allocatorsData = data.allocators;
+    if (!allocatorsData) {
+        for (const item of items) {
+            if (item.id.startsWith("C-A-0")) {
+                item.passed = false;
+                item.message = "Missing required field: allocators";
+            }
+            else {
+                item.passed = true;
+            }
+        }
+        return { all_passed: false, items };
+    }
+    const allocators = allocatorsData.allocators;
+    const ca01 = items.find(i => i.id === "C-A-01");
+    ca01.passed = allocators.length <= MAX_ALLOCATOR_COUNT;
+    ca01.message = ca01.passed ? "" : `Allocator count ${allocators.length} > ${MAX_ALLOCATOR_COUNT}`;
+    let ca02Ok = true;
+    let ca02Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        if (allocators[i].sharing.length > ALLOCATION_MAX_SHARING_COUNT) {
+            ca02Ok = false;
+            ca02Msg = `Allocator ${i} sharing count ${allocators[i].sharing.length} > ${ALLOCATION_MAX_SHARING_COUNT}`;
+            break;
+        }
+    }
+    const ca02 = items.find(i => i.id === "C-A-02");
+    ca02.passed = ca02Ok;
+    ca02.message = ca02Msg;
+    let ca03Ok = true;
+    let ca03Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        const surplusCount = allocators[i].sharing.filter(s => s.mode === "Surplus").length;
+        if (surplusCount > 1) {
+            ca03Ok = false;
+            ca03Msg = `Allocator ${i} has ${surplusCount} Surplus (max 1 allowed)`;
+            break;
+        }
+    }
+    const ca03 = items.find(i => i.id === "C-A-03");
+    ca03.passed = ca03Ok;
+    ca03.message = ca03Msg;
+    let ca04Ok = true;
+    let ca04Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        const a = allocators[i];
+        const rateSum = a.sharing
+            .filter(s => s.mode === "Rate")
+            .reduce((sum, s) => sum + Number(s.sharing), 0);
+        const hasSurplus = a.sharing.some(s => s.mode === "Surplus");
+        const hasRate = a.sharing.some(s => s.mode === "Rate");
+        if (hasRate && !hasSurplus && rateSum !== RATE_TOTAL_FULL) {
+            ca04Ok = false;
+            ca04Msg = `Allocator ${i} pure Rate sum ${rateSum} != ${RATE_TOTAL_FULL}`;
+            break;
+        }
+        if (hasRate && hasSurplus && rateSum > RATE_TOTAL_FULL) {
+            ca04Ok = false;
+            ca04Msg = `Allocator ${i} Rate+Surplus sum ${rateSum} > ${RATE_TOTAL_FULL}`;
+            break;
+        }
+    }
+    const ca04 = items.find(i => i.id === "C-A-04");
+    ca04.passed = ca04Ok;
+    ca04.message = ca04Msg;
+    let ca05Ok = true;
+    let ca05Msg = "";
+    const threshold = Number(allocatorsData.threshold);
+    for (let i = 0; i < allocators.length; i++) {
+        const a = allocators[i];
+        const hasRate = a.sharing.some(s => s.mode === "Rate");
+        const hasSurplus = a.sharing.some(s => s.mode === "Surplus");
+        const amountSum = a.sharing
+            .filter(s => s.mode === "Amount")
+            .reduce((sum, s) => sum + Number(s.sharing), 0);
+        if (!hasRate && !hasSurplus && amountSum > 0 && amountSum < threshold) {
+            ca05Ok = false;
+            ca05Msg = `Allocator ${i} pure Amount sum ${amountSum} < threshold ${threshold}`;
+            break;
+        }
+    }
+    const ca05 = items.find(i => i.id === "C-A-05");
+    ca05.passed = ca05Ok;
+    ca05.message = ca05Msg;
+    let ca06Ok = true;
+    let ca06Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        const a = allocators[i];
+        if (a.max == null)
+            continue;
+        const amountSum = a.sharing
+            .filter(s => s.mode === "Amount")
+            .reduce((sum, s) => sum + Number(s.sharing), 0);
+        if (amountSum > Number(a.max)) {
+            ca06Ok = false;
+            ca06Msg = `Allocator ${i} Amount sum ${amountSum} > max ${Number(a.max)}`;
+            break;
+        }
+    }
+    const ca06 = items.find(i => i.id === "C-A-06");
+    ca06.passed = ca06Ok;
+    ca06.message = ca06Msg;
+    const guardSet = new Set();
+    let ca07Ok = true;
+    let ca07Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        if (guardSet.has(allocators[i].guard)) {
+            ca07Ok = false;
+            ca07Msg = `Allocator ${i} guard ${allocators[i].guard} duplicates an earlier Allocator (F-A-14)`;
+            break;
+        }
+        guardSet.add(allocators[i].guard);
+    }
+    const ca07 = items.find(i => i.id === "C-A-07");
+    ca07.passed = ca07Ok;
+    ca07.message = ca07Msg;
+    let ca08Ok = true;
+    let ca08Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        if (!isValidAddress(allocators[i].guard)) {
+            ca08Ok = false;
+            ca08Msg = `Allocator ${i} guard address ${allocators[i].guard} invalid`;
+            break;
+        }
+    }
+    const ca08 = items.find(i => i.id === "C-A-08");
+    ca08.passed = ca08Ok;
+    ca08.message = ca08Msg;
+    let ca09Ok = true;
+    let ca09Msg = "";
+    outer: for (let i = 0; i < allocators.length; i++) {
+        for (let j = 0; j < allocators[i].sharing.length; j++) {
+            const s = allocators[i].sharing[j];
+            if (isEntityRecipient(s.who)) {
+                const addr = s.who.Entity;
+                if (!isValidAddress(addr)) {
+                    ca09Ok = false;
+                    ca09Msg = `Allocator ${i} sharing ${j} Entity address ${addr} invalid`;
+                    break outer;
+                }
+            }
+        }
+    }
+    const ca09 = items.find(i => i.id === "C-A-09");
+    ca09.passed = ca09Ok;
+    ca09.message = ca09Msg;
+    let ca10Ok = true;
+    let ca10Msg = "";
+    for (let i = 0; i < allocators.length; i++) {
+        const a = allocators[i];
+        const hasSigner = a.sharing.some(s => isSignerRecipient(s.who));
+        if (!hasSigner)
+            continue;
+        const bound = input.guard_signer_bindings?.[a.guard] === true;
+        if (!bound) {
+            ca10Ok = false;
+            ca10Msg = `Allocator ${i} (guard=${a.guard}) has Signer recipient but no Guard Signer binding — R-A-2-01 CRITICAL theft risk`;
+            break;
+        }
+    }
+    const ca10 = items.find(i => i.id === "C-A-10");
+    ca10.passed = ca10Ok;
+    ca10.message = ca10Msg;
+    const ca11 = items.find(i => i.id === "C-A-11");
+    ca11.passed = data.payment_info !== undefined && data.payment_info !== null;
+    ca11.message = ca11.passed ? "" : "payment_info missing — required at alloc() time (ENO_PAYMENT_INFO=9)";
+    const ca12 = items.find(i => i.id === "C-A-12");
+    const obj = data.object;
+    if (obj.type_parameter && data.coin) {
+        ca12.passed = true;
+        ca12.message = "";
+    }
+    else if (!obj.type_parameter) {
+        ca12.passed = false;
+        ca12.message = "type_parameter missing on object";
+    }
+    else {
+        ca12.passed = false;
+        ca12.message = "coin missing — required for create";
+    }
+    return {
+        all_passed: items.every(i => i.passed),
+        items,
+    };
+}
+function adaptRiskAssessment(input, _checklist) {
+    const ctx = {
+        object: typeof input.allocation_json.object === "string" ? input.allocation_json.object : null,
+        allocators_config: input.allocation_json.allocators,
+        operation_type: input.operation_type ?? "create",
+        has_payment_info: input.allocation_json.payment_info !== undefined,
+        host_service_published: true,
+        referenced_treasuries_permissions: input.referenced_treasuries_permissions,
+        guard_signer_bindings: input.guard_signer_bindings,
+        passport_identifier_types: input.passport_identifier_types,
+        guard_conditions_mutually_exclusive: input.guard_conditions_mutually_exclusive,
+        bound_order: input.bound_order,
+        order_already_has_allocation: input.order_already_has_allocation,
+    };
+    return assessAllocationRisks(ctx);
+}
+export const ALLOCATION_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QA1",
+        question: "Are all Treasury / Entity recipient addresses correctly verified as trusted parties?",
+        requires_explicit_yes: true,
+    },
+    {
+        id: "QA2",
+        question: "If using multiple Allocators (caller-specified guard), are Guard conditions mutually exclusive to prevent caller confusion or silent lockup (alloc_by_guard silently returns on no match)?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-A-4-02"],
+    },
+    {
+        id: "QA3",
+        question: "⚠️ If using sharing.who=Signer: is the Guard Signer binding verified (context(Signer)==authorized)? Signer without Guard binding = CRITICAL theft risk.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-A-2-01"],
+    },
+    {
+        id: "QA4",
+        question: "If using Amount+Surplus hybrid (refund-first): is threshold set to refund amount (fix) to ensure balance covers the Amount distribution?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-A-1-03"],
+    },
+    {
+        id: "QA5",
+        question: "Is payment_info correctly configured? alloc() will abort with ENO_PAYMENT_INFO (9) if missing.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-A-5-02"],
+    },
+    {
+        id: "QA6",
+        question: "Has the Allocation been tested on testnet? Allocation is a 'passive object' — once created, allocators cannot be reconfigured.",
+        requires_explicit_yes: false,
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const questions = [...ALLOCATION_CONFIRMATION_QUESTIONS];
+    const hasSignerRecipient = input.allocation_json.allocators?.allocators.some(a => a.sharing.some(s => isSignerRecipient(s.who))) ?? false;
+    if (!hasSignerRecipient) {
+        const idx = questions.findIndex(q => q.id === "QA3");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    const allocatorCount = input.allocation_json.allocators?.allocators.length ?? 0;
+    if (allocatorCount <= 1) {
+        const idx = questions.findIndex(q => q.id === "QA2");
+        if (idx >= 0)
+            questions.splice(idx, 1);
+    }
+    const hasAmountSurplusHybrid = input.allocation_json.allocators?.allocators.some(a => a.sharing.some(s => s.mode === "Amount") && a.sharing.some(s => s.mode === "Surplus")) ?? false;
+    if (!hasAmountSurplusHybrid) {
+        const idx = questions.findIndex(q => q.id === "QA4");
+        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.allocation_json.object === "string") {
+        checks.push({
+            name: "object_exists",
+            passed: true,
+            message: `Allocation object ${input.allocation_json.object} assumed to exist`,
+        });
+    }
+    if (input.allocation_json.alloc_by_guard) {
+        const guard = input.allocation_json.alloc_by_guard;
+        const allocators = input.allocation_json.allocators?.allocators ?? [];
+        const valid = isValidAddress(guard);
+        checks.push({
+            name: "alloc_by_guard_valid",
+            passed: valid,
+            message: valid
+                ? `Guard ${guard} address valid (SDK will verify it exists in allocators[].guard)`
+                : `Guard ${guard} address invalid`,
+        });
+    }
+    if (input.operation_type === "create") {
+        checks.push({
+            name: "signer_authorized",
+            passed: true,
+            message: "Signer must hold SERVICE_ORDER_ALLOCATOR=313 permission (or ARBITRATION_FEES_ALLOC=365 for arbitration fees)",
+        });
+    }
+    if (input.bound_order) {
+        const alreadyHas = input.order_already_has_allocation === true;
+        checks.push({
+            name: "order_allocation_1to1",
+            passed: !alreadyHas,
+            message: alreadyHas
+                ? `Order ${input.bound_order} already has an Allocation — E_ALLOCATION_ALREADY_SPECIFIED will abort`
+                : `Order ${input.bound_order} has no Allocation — 1:1 constraint satisfied`,
+        });
+    }
+    checks.push({
+        name: "testnet_test_recommended",
+        passed: true,
+        message: "Allocation is a 'passive object' — strongly recommend testnet test before mainnet deployment",
+    });
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const ALLOCATION_CONFIRM_VERSION = "1.0.0";
+export function runAllocationConfirmGate(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: ALLOCATION_CONFIRM_VERSION,
+                final_status: "blocked_checklist",
+                layers_passed: layersPassed,
+                layers_failed: layersFailed,
+            },
+        };
+    }
+    layersPassed.push("L1_checklist");
+    const assessment = adaptRiskAssessment(input, checklist);
+    if (assessment.blocks_publish) {
+        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: ALLOCATION_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) {
+    }
+    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: ALLOCATION_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: ALLOCATION_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.allocation_json;
+    lines.push("═══ Allocation Confirmation ═══");
+    lines.push("");
+    const isCreate = data.object !== null &&
+        data.object !== undefined &&
+        typeof data.object === "object";
+    if (isCreate) {
+        const obj = data.object;
+        lines.push(`Allocation: NEW '${obj.name}' (${obj.type_parameter ?? "<missing>"})`);
+    }
+    else if (typeof data.object === "string") {
+        lines.push(`Allocation: OPERATE ${data.object}`);
+    }
+    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 (isCreate && data.allocators) {
+        lines.push(`- Description: ${data.allocators.description}`);
+        lines.push(`- Threshold: ${data.allocators.threshold}`);
+        lines.push(`- Allocators: ${data.allocators.allocators.length}`);
+        data.allocators.allocators.forEach((a, i) => {
+            const surplusCount = a.sharing.filter(s => s.mode === "Surplus").length;
+            const rateSum = a.sharing.filter(s => s.mode === "Rate").reduce((sum, s) => sum + Number(s.sharing), 0);
+            const amountSum = a.sharing.filter(s => s.mode === "Amount").reduce((sum, s) => sum + Number(s.sharing), 0);
+            lines.push(`  [${i}] guard=${a.guard}, sharing=${a.sharing.length} (Rate sum=${rateSum}, Amount sum=${amountSum}, Surplus=${surplusCount}), max=${a.max ?? "null"}`);
+        });
+    }
+    if (data.received_coins) {
+        lines.push(`- Receive: ${data.received_coins.received.length} CoinWrapper deposit(s)`);
+    }
+    if (data.alloc_by_guard) {
+        lines.push(`- Alloc by Guard: ${data.alloc_by_guard}`);
+    }
+    lines.push("");
+    lines.push("─ Error Code Reference ──────────────────");
+    lines.push(`  EALLOCATORS_EMPTY=${ALLOCATION_ERROR_CODES.EALLOCATORS_EMPTY}, ENO_ALLOCATOR=${ALLOCATION_ERROR_CODES.ENO_ALLOCATOR}, ERATE_NOT_10000=${ALLOCATION_ERROR_CODES.ERATE_NOT_10000}`);
+    lines.push(`  EMULTIPLE_SURPLUS=${ALLOCATION_ERROR_CODES.EMULTIPLE_SURPLUS}, ERATE_EXCEEDS_10000=${ALLOCATION_ERROR_CODES.ERATE_EXCEEDS_10000}, EINSUFFICIENT_BALANCE=${ALLOCATION_ERROR_CODES.EINSUFFICIENT_BALANCE}`);
+    lines.push(`  ENO_PAYMENT_INFO=${ALLOCATION_ERROR_CODES.ENO_PAYMENT_INFO}, ESHARING_COUNT_EXCEEDED=${ALLOCATION_ERROR_CODES.ESHARING_COUNT_EXCEEDED}, EAMOUNT_BELOW_THRESHOLD=${ALLOCATION_ERROR_CODES.EAMOUNT_BELOW_THRESHOLD}`);
+    lines.push(`  EAMOUNT_EXCEEDS_MAX=${ALLOCATION_ERROR_CODES.EAMOUNT_EXCEEDS_MAX}, EALLOCATOR_COUNT_EXCEEDED=${ALLOCATION_ERROR_CODES.EALLOCATOR_COUNT_EXCEEDED}`);
+    lines.push("");
+    return lines.join("\n");
+}
+export function progressiveAllocationCheck(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 (C-A-XX)",
+        };
+    }
+    const assessment = adaptRiskAssessment(input, checklist);
+    if (assessment.blocks_publish) {
+        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 (R-A-1-01 empty allocators, R-A-2-01 Signer theft) before proceeding",
+        };
+    }
+    if (assessment.needs_human_review) {
+        return {
+            stage: "confirmation",
+            status: "pending",
+            message: "Human review required for HIGH risks",
+            next_action: "Confirm risk acceptance (QA1 ~ QA6)",
+        };
+    }
+    return {
+        stage: "complete",
+        status: "pass",
+        message: "All checks passed",
+    };
+}

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

@@ -0,0 +1,58 @@
+import { type AllocationScene, type AllocationMode, type TriggerSource } from "./allocation-ledger.js";
+import { type AllocationTemplate } from "./allocation-templates.js";
+import { type SemanticToSchemaRule } from "./allocation-translation.js";
+import { type AllocationRiskRule, type AllocationRiskAssessment, type AllocationStakeholder } from "./allocation-risk.js";
+import { type AllocationPuzzle, type AllocationPuzzleCompleteness } from "./allocation-puzzle.js";
+import { type ChecklistItem, type ConfirmationQuestion, type AllocationJsonForConfirm } from "./allocation-confirm.js";
+export declare const ALLOCATION_CONTEXT_VERSION = "1.0.0";
+export type AllocationInjectionMode = "initial_design" | "mid_design_review" | "pre_publish" | "post_publish_modify" | "stakeholder_review" | "apply_check";
+export type AllocationStakeholderPerspective = AllocationStakeholder | "system";
+export interface AllocationContextBundle {
+    version: string;
+    mode: AllocationInjectionMode;
+    stakeholder_perspective?: AllocationStakeholderPerspective;
+    matched_scene?: AllocationScene;
+    matched_template?: AllocationTemplate;
+    matched_pattern?: SemanticToSchemaRule;
+    puzzle_state?: AllocationPuzzle;
+    puzzle_completeness?: AllocationPuzzleCompleteness;
+    relevant_risks: AllocationRiskRule[];
+    risk_assessment?: AllocationRiskAssessment;
+    relevant_checklist: ChecklistItem[];
+    relevant_questions: ConfirmationQuestion[];
+    cross_object_refs: AllocationCrossObjectRef[];
+    onchain_constraints: AllocationOnchainConstraint[];
+    rendering_hints: AllocationRenderingHints;
+}
+export interface AllocationCrossObjectRef {
+    object: "Service" | "Order" | "Arbitration" | "Treasury" | "Guard" | "Passport" | "Progress" | "Machine" | "Payment";
+    field: string;
+    scene_id: string;
+    description: string;
+}
+export interface AllocationOnchainConstraint {
+    name: string;
+    value: string | number;
+    description: string;
+}
+export interface AllocationRenderingHints {
+    include_puzzle_template: boolean;
+    include_risk_details: boolean;
+    include_questions: boolean;
+    include_immutability_warning: boolean;
+    include_trigger_warning: boolean;
+    include_rate_overflow_warning: boolean;
+    max_length: number;
+}
+export interface BuildAllocationContextInput {
+    mode: AllocationInjectionMode;
+    intent?: string;
+    allocation_json?: AllocationJsonForConfirm;
+    stakeholder?: AllocationStakeholderPerspective;
+    target_trigger_source?: TriggerSource;
+    target_mode?: AllocationMode;
+    max_length?: number;
+}
+export declare function buildAllocationContext(input: BuildAllocationContextInput): AllocationContextBundle;
+export declare function buildPromptFromAllocationContext(bundle: AllocationContextBundle): string;
+export declare function getAllocationContextSummary(bundle: AllocationContextBundle): string;