@wowok/agent-mcp 2.3.16 → 2.3.18

package/dist/knowledge/acquisition-flywheel.d.ts

@@ -24,6 +24,9 @@ export interface TrustDescriptionParams {
 }
 export declare const ACQUISITION_FLYWHEEL_VERSION = 1;
 export declare const INDUSTRY_FLYWHEELS: AcquisitionFlywheel[];
+export declare function _setRegistryLookup(fn: ((industry: string) => {
+    flywheel?: AcquisitionFlywheel;
+} | undefined) | null): void;
 export declare function getFlywheelForIndustry(industry: string): AcquisitionFlywheel | undefined;
 export declare function listIndustries(): string[];
 export declare function suggestAcquisitionActions(industry: string): FlywheelAction[];

package/dist/knowledge/acquisition-flywheel.js

@@ -91,7 +91,16 @@ export const INDUSTRY_FLYWHEELS = [
         trustDescription: "交易托管 + 物流 Guard + 退款保障",
     },
 ];
+let _registryLookup = null;
+export function _setRegistryLookup(fn) {
+    _registryLookup = fn;
+}
 export function getFlywheelForIndustry(industry) {
+    if (_registryLookup) {
+        const profile = _registryLookup(industry);
+        if (profile?.flywheel)
+            return profile.flywheel;
+    }
     return INDUSTRY_FLYWHEELS.find((f) => f.industry === industry.toLowerCase());
 }
 export function listIndustries() {

package/dist/knowledge/guard-ledger.d.ts

@@ -0,0 +1,19 @@
+export interface GuardScene {
+    id: string;
+    name: string;
+    host_object: "Service" | "Machine" | "Arbitration" | "Reward" | "Repository" | "Progress" | "Demand" | "Standalone";
+    binding_field: string;
+    validation_scene: string;
+    pass_result: string;
+    fail_result: string;
+    submission_source: string;
+    special_constraints: string[];
+    common_patterns: string[];
+    mutable_after_publish: boolean;
+    r_rounds_focus: string[];
+}
+export declare const GUARD_SCENES: GuardScene[];
+export declare function findScene(host_object: string, binding_field: string): GuardScene | undefined;
+export declare function inferSceneFromAction(action: "buy" | "forward" | "allocate" | "claim_reward" | "vote" | "dispute" | "write_repository" | "submit_progress"): GuardScene | undefined;
+export declare function getImmutableScenes(): GuardScene[];
+export declare function getNumericIdentifierScenes(): GuardScene[];

package/dist/knowledge/guard-ledger.js

@@ -0,0 +1,219 @@
+export const GUARD_SCENES = [
+    {
+        id: "service_buy_guard",
+        name: "服务购买验证（buy_guard）",
+        host_object: "Service",
+        binding_field: "buy_guard",
+        validation_scene: "客户下单购买服务时，Guard 验证客户是否有资格购买（身份/许可/条件）",
+        pass_result: "创建 Order 对象，客户进入支付流程",
+        fail_result: "交易拒绝，Order 不创建，客户无法购买",
+        submission_source: "Customer（signer 地址、credentials、Passport 等）",
+        special_constraints: [
+            "Guard table 必须声明所有客户需要提交的数据",
+            "b_submission=true 条目的 name 必须是自然语言描述（客户看到的契约）",
+            "如果 Guard 引用 Service 本身，使用循环引用模式（CREATE Service → CREATE Guard → MODIFY Service）",
+            "Service 发布后 buy_guard 仍可修改（通过 MODIFY Service）",
+        ],
+        common_patterns: [
+            "身份检查：context(Signer) + logic_equal（单地址）/ vec_contains_address（白名单）",
+            "会员验证：query EntityRegistrar(0xaab) + logic_and 组合",
+            "时间限制：context(Clock) + logic_as_u256_greater_or_equal",
+            "多条件：logic_and 组合多个检查",
+        ],
+        mutable_after_publish: true,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R9"],
+    },
+    {
+        id: "service_order_allocators_guard",
+        name: "分账策略选择验证（order_allocators[].guard）",
+        host_object: "Service",
+        binding_field: "order_allocators",
+        validation_scene: "订单完成或满足分账条件时，系统按 order_allocators 顺序评估每个 Allocator 的 Guard，" +
+            "第一个通过的 Guard 对应的 Allocator 执行分账",
+        pass_result: "执行该 Allocator 的分账策略（按比例/按条件分配资金）",
+        fail_result: "跳过此 Allocator，尝试下一个（first-match-wins）。如果所有 Allocator 都失败，资金不分配",
+        submission_source: "System 从 Progress 状态自动派生（无需客户显式提交）",
+        special_constraints: [
+            "order_allocators 顺序敏感：第一个 Guard 通过的 Allocator 执行分账",
+            "Service 发布后 order_allocators 不可修改（immutable）",
+            "Guard 通常查询 Order/Progress 状态判断分账条件",
+            "常用 query: order.amount, progress.current_node, order.completed 等",
+            "GuardIdentifier 可用于动态金额（从 table 提取 u64 值作为分账比例）",
+        ],
+        common_patterns: [
+            "节点状态检查：query(Progress.current_node) + logic_equal('Completed')",
+            "金额阈值：query(Order.amount) + logic_as_u256_greater_or_equal(threshold)",
+            "多条件组合：logic_and（节点状态 + 金额 + 时间）",
+            "GuardIdentifier 动态比例：table[u64] 提取分账比例",
+        ],
+        mutable_after_publish: false,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
+    },
+    {
+        id: "machine_forward_guard",
+        name: "工作流节点推进验证（Forward.guard）",
+        host_object: "Machine",
+        binding_field: "Forward.guard",
+        validation_scene: "客户或商家执行 Forward 操作推进工作流时，Guard 验证是否允许推进到下一节点",
+        pass_result: "Progress 推进到 next_node，session 累计权重",
+        fail_result: "Forward 阻塞，Progress 停留在当前节点。可选 retained_submission 留存审计数据",
+        submission_source: "执行 Forward 的一方（Customer 或 Provider，取决于 Forward 配置）",
+        special_constraints: [
+            "Machine 发布后 Forward.guard 不可修改（需新建 Machine）",
+            "可选 retained_submission：将提交数据存入 Progress 供后续审计",
+            "retained_submission 索引必须与 Guard table 对应",
+            "常用 query: progress.current_node, progress.session_forward, order.service 等",
+            "时间锁：context(Clock) + calc_number_add(progress.entry_time, duration) 测试用 1000ms",
+        ],
+        common_patterns: [
+            "身份检查：context(Signer) + logic_equal（只有特定方可推进）",
+            "时间锁：context(Clock) + calc_number_add + logic_as_u256_greater_or_equal",
+            "前置 Forward 完成：query_progress_history_find + logic_equal(accomplished=true)",
+            "提交数据验证：identifier(submission) + logic_equal(expected_value)",
+            "跨对象查询：convert_witness=TypeOrderProgress(100) 从 Order 查 Progress",
+        ],
+        mutable_after_publish: false,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7", "R8", "R9"],
+    },
+    {
+        id: "progress_submission_guard",
+        name: "Progress 提交数据验证（submission guard）",
+        host_object: "Progress",
+        binding_field: "submission",
+        validation_scene: "Forward 执行时提交的数据（如签名、凭证、确认）是否满足 Guard 条件",
+        pass_result: "Forward 完成，session 累计权重达到阈值后推进节点",
+        fail_result: "Forward 不完成，等待重新提交或满足条件",
+        submission_source: "提交数据的一方（Customer 或 Provider）",
+        special_constraints: [
+            "与 Forward.guard 协同：Forward.guard 验证资格，submission guard 验证数据",
+            "retained_submission 将提交数据存入 Progress session 供审计",
+            "常用 query: progress.session_forward, progress.session_weight 等",
+        ],
+        common_patterns: [
+            "签名验证：identifier(signature_submission) + logic_equal(expected)",
+            "凭证验证：query(Repository.data) + logic_equal(submission_proof)",
+            "确认验证：identifier(confirm_submission) + logic_equal(true)",
+        ],
+        mutable_after_publish: false,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R8"],
+    },
+    {
+        id: "reward_guard",
+        name: "奖励领取验证（Reward.guard）",
+        host_object: "Reward",
+        binding_field: "guard",
+        validation_scene: "用户领取奖励池时，Guard 验证是否有资格领取",
+        pass_result: "奖励发放给 Claimant，记录到 reward_record",
+        fail_result: "领取拒绝，奖励不发",
+        submission_source: "Claimant（address、credentials、Passport）",
+        special_constraints: [
+            "常用 query_reward_record_count 防重复领取（one-time claim）",
+            "Guard 通常查询历史记录 + 时间条件 + 身份验证",
+            "如果 Reward 引用 Service，使用循环引用模式",
+        ],
+        common_patterns: [
+            "一次性领取：query_reward_record_count(recipient) + logic_equal(0)",
+            "时间窗口：context(Clock) + logic_as_u256_greater_or_equal(start_time)",
+            "身份验证：context(Signer) + vec_contains_address(allowlist)",
+            "多条件：logic_and（身份 + 时间 + 未领取过）",
+        ],
+        mutable_after_publish: true,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R8", "R9"],
+    },
+    {
+        id: "repository_write_guard",
+        name: "存储写入验证（write_guard）",
+        host_object: "Repository",
+        binding_field: "write_guard",
+        validation_scene: "写入链上存储时，Guard 验证写入资格并可选提取数据",
+        pass_result: "写入成功；可选 id_from_submission 提取 entity ID，data_from_submission 提取数据值",
+        fail_result: "写入拒绝",
+        submission_source: "Writer/Reader",
+        special_constraints: [
+            "id_from_submission 引用的 table 条目必须是 Address 类型",
+            "data_from_submission 引用的 table 条目必须匹配 Repository 的 value_type",
+            "类型不匹配导致写入失败或数据损坏",
+            "常用于 oracle 数据写入、第三方凭证存证等场景",
+        ],
+        common_patterns: [
+            "授权写入者：context(Signer) + vec_contains_address(authorized_writers)",
+            "数据格式验证：identifier(data_submission) + logic_string_contains(expected_prefix)",
+            "ID 提取：id_from_submission + data_from_submission 组合",
+        ],
+        mutable_after_publish: true,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
+    },
+    {
+        id: "arbitration_usage_guard",
+        name: "争议发起验证（usage_guard）",
+        host_object: "Arbitration",
+        binding_field: "usage_guard",
+        validation_scene: "客户对订单发起争议时，Guard 验证客户是否有资格发起争议",
+        pass_result: "创建 Arb 案件，进入仲裁流程",
+        fail_result: "争议拒绝，Arb 不创建",
+        submission_source: "Customer（Passport credential）",
+        special_constraints: [
+            "Arbitration bPaused=true 时优先阻塞（先于 Guard 检查）",
+            "客户需先生成 Passport（gen_passport 通过 usage_guard）",
+            "常用 query: order.completed, order.service, entity.has 等",
+            "Guard 验证客户身份 + 订单状态 + 争议资格",
+        ],
+        common_patterns: [
+            "订单状态验证：query(Order.status) + logic_equal('completed')",
+            "会员验证：query(EntityRegistrar) + logic_and",
+            "时间窗口：query(Order.time) + calc_number_add + context(Clock)",
+            " Passport 凭证：identifier(passport_submission) + context(Signer)",
+        ],
+        mutable_after_publish: true,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R7", "R8", "R9"],
+    },
+    {
+        id: "arbitration_voting_guard",
+        name: "仲裁投票权重验证（voting_guard[]）",
+        host_object: "Arbitration",
+        binding_field: "voting_guard",
+        validation_scene: "仲裁员投票时，Guard 验证投票资格并从 GuardIdentifier 提取投票权重（u32）",
+        pass_result: "投票计入，权重为 GuardIdentifier 提取的数值",
+        fail_result: "投票拒绝",
+        submission_source: "Voter（Passport credential with weight data）",
+        special_constraints: [
+            "GuardIdentifier 引用的 table 条目必须是 numeric 类型（U8-U256），cast 为 u32",
+            "非 numeric 类型导致 E_GUARD_IDENTIFIER_NOT_NUMBER 错误",
+            "b_submission 必须 true（权重由 voter 运行时提交）",
+            "可配置多个 voting_guard，每个对应不同投票者群体",
+            "Arbitration bPaused=true 时阻塞投票",
+        ],
+        common_patterns: [
+            "声誉分权重：query(EntityRegistrar.records[reputation]) + GuardIdentifier(u64)",
+            "固定权重：identifier(constant_weight) + GuardIdentifier",
+            "多级投票：不同 voting_guard 对应不同权重等级",
+            "资格 + 权重：logic_and（资格检查 + GuardIdentifier 提取权重）",
+        ],
+        mutable_after_publish: true,
+        r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7", "R8", "R9"],
+    },
+];
+export function findScene(host_object, binding_field) {
+    return GUARD_SCENES.find((s) => s.host_object === host_object &&
+        s.binding_field === binding_field);
+}
+export function inferSceneFromAction(action) {
+    const map = {
+        buy: "service_buy_guard",
+        forward: "machine_forward_guard",
+        allocate: "service_order_allocators_guard",
+        claim_reward: "reward_guard",
+        vote: "arbitration_voting_guard",
+        dispute: "arbitration_usage_guard",
+        write_repository: "repository_write_guard",
+        submit_progress: "progress_submission_guard",
+    };
+    const id = map[action];
+    return GUARD_SCENES.find((s) => s.id === id);
+}
+export function getImmutableScenes() {
+    return GUARD_SCENES.filter((s) => !s.mutable_after_publish);
+}
+export function getNumericIdentifierScenes() {
+    return GUARD_SCENES.filter((s) => s.special_constraints.some((c) => c.includes("numeric") || c.includes("GuardIdentifier")));
+}

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

@@ -0,0 +1,93 @@
+export interface IntentPuzzle {
+    action: "buy" | "forward" | "allocate" | "claim_reward" | "vote" | "dispute" | "write_repository" | "submit_progress" | "gen_passport" | "custom";
+    rule_sentence: string;
+    failure_conditions: string[];
+}
+export interface BindingPuzzle {
+    host_object: "Service" | "Machine" | "Arbitration" | "Reward" | "Repository" | "Progress" | "Demand" | "Standalone";
+    host_object_name?: string;
+    binding_field: "buy_guard" | "order_allocators" | "Forward.guard" | "submission" | "guard" | "write_guard" | "usage_guard" | "voting_guard" | "ServiceGuard" | "none";
+    circular_reference: boolean;
+    host_object_state: "not_created" | "created_unpublished" | "published_immutable" | "unknown";
+}
+export interface DataEntryPuzzle {
+    identifier: number;
+    b_submission: boolean;
+    value_type: string;
+    value?: string | number | boolean | string[];
+    name: string;
+    object_type?: string;
+    is_system_address?: boolean;
+}
+export interface WitnessUsagePuzzle {
+    witness_type: number;
+    witness_name: string;
+    source_type: string;
+    target_type: string;
+    scenario: string;
+}
+export interface QueryPuzzle {
+    query_id: number;
+    query_name: string;
+    object_type: string;
+    parameters: string[];
+    return_type: string;
+    witness?: WitnessUsagePuzzle;
+    purpose: string;
+}
+export interface LogicNodePuzzle {
+    node_type: string;
+    return_type: string;
+    children?: LogicNodePuzzle[];
+    references_identifier?: number;
+    query?: QueryPuzzle;
+    description: string;
+}
+export interface RelyPuzzle {
+    guards: string[];
+    logic_or: boolean;
+    rep_verified: boolean[];
+}
+export interface ConstraintChecklist {
+    pitfall_01_identifiers_in_table: boolean;
+    pitfall_02_type_compatibility: boolean;
+    pitfall_03_query_instruction_valid: boolean;
+    pitfall_04_witness_correct: boolean;
+    pitfall_05_time_lock_test_safe: boolean;
+    pitfall_06_exported_before_recreate: boolean;
+    pitfall_07_root_returns_bool: boolean;
+    pitfall_08_rely_rep_true: boolean;
+    pitfall_09_voting_weight_numeric: boolean;
+    pitfall_10_arbitration_not_paused: boolean;
+}
+export interface GuardPuzzle {
+    current_round: "R1" | "R2" | "R3" | "R4" | "R5" | "R6" | "R7" | "R8" | "R9" | "R10";
+    intent?: IntentPuzzle;
+    binding?: BindingPuzzle;
+    data?: {
+        entries: DataEntryPuzzle[];
+        witnesses: WitnessUsagePuzzle[];
+    };
+    queries?: QueryPuzzle[];
+    logic?: {
+        root: LogicNodePuzzle;
+        rely?: RelyPuzzle;
+    };
+    constraints?: ConstraintChecklist;
+}
+export type PuzzleDimension = "intent" | "binding" | "data" | "query" | "logic" | "constraints";
+export interface PuzzleCompleteness {
+    dimensions: Record<PuzzleDimension, boolean>;
+    missing: PuzzleDimension[];
+    missing_details: string[];
+    complete: boolean;
+    next_step: {
+        round: GuardPuzzle["current_round"];
+        action: string;
+        questions: string[];
+    };
+}
+export declare function checkPuzzleCompleteness(puzzle: GuardPuzzle): PuzzleCompleteness;
+export declare function generateConfirmationText(puzzle: GuardPuzzle): string;
+export declare function initPuzzleFromIntent(intent: Partial<IntentPuzzle>): GuardPuzzle;
+export declare function inferBindingFromAction(action: IntentPuzzle["action"]): Partial<BindingPuzzle>;

package/dist/knowledge/guard-puzzle.js

@@ -0,0 +1,278 @@
+export function checkPuzzleCompleteness(puzzle) {
+    const dimensions = {
+        intent: isIntentComplete(puzzle.intent),
+        binding: isBindingComplete(puzzle.binding),
+        data: isDataComplete(puzzle.data),
+        query: isQueryComplete(puzzle.queries),
+        logic: isLogicComplete(puzzle.logic),
+        constraints: isConstraintsComplete(puzzle.constraints),
+    };
+    const missing = Object.keys(dimensions).filter((k) => !dimensions[k]);
+    const missing_details = [];
+    if (!dimensions.intent) {
+        missing_details.push("A. 意图：未明确被保护动作、验证规则或失败条件");
+    }
+    if (!dimensions.binding) {
+        missing_details.push("B. 绑定：未确定 Host Object、绑定字段或循环引用模式");
+    }
+    if (!dimensions.data) {
+        missing_details.push("C. 数据：未声明 table 条目（常量/提交）或 convert_witness");
+    }
+    if (!dimensions.query) {
+        missing_details.push("D. 查询：未确定查询指令（如果 Guard 需要查询链上数据）");
+    }
+    if (!dimensions.logic) {
+        missing_details.push("E. 逻辑：未设计计算树 root 或 rely 组合");
+    }
+    if (!dimensions.constraints) {
+        missing_details.push("F. 约束：未完成 10 项 Common Pitfalls 检查");
+    }
+    const complete = missing.length === 0;
+    const next_step = recommendNextStep(puzzle, missing);
+    return { dimensions, missing, missing_details, complete, next_step };
+}
+function isIntentComplete(intent) {
+    return !!intent && !!intent.action && !!intent.rule_sentence && intent.failure_conditions.length > 0;
+}
+function isBindingComplete(binding) {
+    return !!binding && !!binding.host_object && !!binding.binding_field;
+}
+function isDataComplete(data) {
+    return !!data && data.entries.length > 0;
+}
+function isQueryComplete(queries) {
+    return true;
+}
+function isLogicComplete(logic) {
+    return !!logic && !!logic.root && logic.root.return_type === "Bool";
+}
+function isConstraintsComplete(constraints) {
+    if (!constraints)
+        return false;
+    return Object.values(constraints).every((v) => v === true);
+}
+function recommendNextStep(puzzle, missing) {
+    if (missing.includes("intent")) {
+        return {
+            round: "R1",
+            action: "捕获验证意图",
+            questions: [
+                "你要保护什么动作？（buy/forward/claim/vote/dispute/write/allocate）",
+                "用一句话描述验证规则",
+                "列出 Guard 应该 FAIL 的情况",
+            ],
+        };
+    }
+    if (missing.includes("binding")) {
+        return {
+            round: "R5",
+            action: "确定绑定目标",
+            questions: [
+                "Guard 将绑定到哪个 Host Object？（Service/Machine/Arbitration/Reward/Repository）",
+                "绑定到哪个字段？（buy_guard/order_allocators/Forward.guard/...）",
+                "Guard 是否需要引用 Host Object？（循环引用模式）",
+            ],
+        };
+    }
+    if (missing.includes("data")) {
+        return {
+            round: "R2",
+            action: "声明数据表",
+            questions: [
+                "Guard 需要哪些常量数据？（已知且不变的值）",
+                "Guard 需要哪些提交数据？（运行时由 caller 提供）",
+                "每个提交数据的 value_type 是什么？",
+                "是否需要查询 EntityRegistrar(0xaab) 或 EntityLinker(0xaaa)？",
+            ],
+        };
+    }
+    if (missing.includes("query")) {
+        return {
+            round: "R3",
+            action: "设计查询节点",
+            questions: [
+                "Guard 需要查询哪些链上对象？",
+                "每个查询使用哪个指令 ID？（从 GUARDQUERY 查询）",
+                "是否需要 convert_witness 转换对象？",
+            ],
+        };
+    }
+    if (missing.includes("logic")) {
+        return {
+            round: "R3",
+            action: "设计计算树",
+            questions: [
+                "root 节点是什么？（必须返回 Bool）",
+                "数据源节点有哪些？（identifier/context/query）",
+                "中间转换节点有哪些？（calc_*/convert_*/vec_*）",
+                "是否需要 rely 组合其他 Guard？",
+            ],
+        };
+    }
+    if (missing.includes("constraints")) {
+        return {
+            round: "R6",
+            action: "预创建审查",
+            questions: ["运行 10 项 Common Pitfalls 检查清单"],
+        };
+    }
+    return {
+        round: "R7",
+        action: "准备链上创建",
+        questions: ["所有维度已补全，准备生成语义确认文本"],
+    };
+}
+export function generateConfirmationText(puzzle) {
+    if (!puzzle.intent || !puzzle.binding || !puzzle.data || !puzzle.logic) {
+        return "【拼图未完整】无法生成确认文本，请先补全所有维度";
+    }
+    const lines = [];
+    lines.push("═══════════════════════════════════════════════════════");
+    lines.push("  Guard 语义确认报告（用户审核版）");
+    lines.push("═══════════════════════════════════════════════════════");
+    lines.push("");
+    lines.push("【意图】");
+    lines.push(`被保护动作: ${puzzle.intent.action}`);
+    lines.push(`验证规则: ${puzzle.intent.rule_sentence}`);
+    lines.push("失败条件:");
+    puzzle.intent.failure_conditions.forEach((c, i) => {
+        lines.push(`  ${i + 1}. ${c}`);
+    });
+    lines.push("");
+    lines.push("【绑定】");
+    lines.push(`Host Object: ${puzzle.binding.host_object}`);
+    if (puzzle.binding.host_object_name) {
+        lines.push(`Host Object 名称: ${puzzle.binding.host_object_name}`);
+    }
+    lines.push(`绑定字段: ${puzzle.binding.binding_field}`);
+    lines.push(`循环引用: ${puzzle.binding.circular_reference ? "是（Guard 引用 Host Object）" : "否"}`);
+    lines.push(`Host Object 状态: ${puzzle.binding.host_object_state}`);
+    lines.push("");
+    lines.push("【数据表】");
+    lines.push("┌─────┬──────────┬──────────┬───────────────┬─────────────────────────┐");
+    lines.push("│ ID  │ 类型     │ 提交/常量│ 值/占位       │ 名称描述                │");
+    lines.push("├─────┼──────────┼──────────┼───────────────┼─────────────────────────┤");
+    puzzle.data.entries.forEach((e) => {
+        const id = String(e.identifier).padEnd(3);
+        const type = e.value_type.padEnd(8);
+        const src = (e.b_submission ? "提交" : "常量").padEnd(8);
+        const val = (e.b_submission ? "(运行时)" : String(e.value ?? "")).padEnd(13);
+        const name = e.name.length > 23 ? e.name.slice(0, 22) + "…" : e.name.padEnd(23);
+        lines.push(`│ ${id} │ ${type} │ ${src} │ ${val} │ ${name} │`);
+    });
+    lines.push("└─────┴──────────┴──────────┴───────────────┴─────────────────────────┘");
+    if (puzzle.data.witnesses.length > 0) {
+        lines.push("");
+        lines.push("【对象转换 (convert_witness)】");
+        puzzle.data.witnesses.forEach((w) => {
+            lines.push(`  ${w.witness_type} (${w.witness_name}): ${w.source_type} → ${w.target_type}`);
+            lines.push(`    场景: ${w.scenario}`);
+        });
+    }
+    lines.push("");
+    if (puzzle.queries && puzzle.queries.length > 0) {
+        lines.push("【查询指令】");
+        lines.push("┌──────┬──────────────────────────┬────────────┬──────────┬──────────┐");
+        lines.push("│ ID   │ 查询指令                 │ 目标对象   │ 参数     │ 返回类型 │");
+        lines.push("├──────┼──────────────────────────┼────────────┼──────────┼──────────┤");
+        puzzle.queries.forEach((q) => {
+            const id = String(q.query_id).padEnd(4);
+            const name = q.query_name.length > 24 ? q.query_name.slice(0, 23) + "…" : q.query_name.padEnd(24);
+            const obj = q.object_type.padEnd(10);
+            const params = (q.parameters.length === 0 ? "(无)" : q.parameters.join(",")).padEnd(8);
+            const ret = q.return_type.padEnd(8);
+            lines.push(`│ ${id} │ ${name} │ ${obj} │ ${params} │ ${ret} │`);
+        });
+        lines.push("└──────┴──────────────────────────┴────────────┴──────────┴──────────┘");
+        lines.push("");
+    }
+    lines.push("【计算树】");
+    lines.push(`root: ${puzzle.logic.root.node_type} (返回: ${puzzle.logic.root.return_type})`);
+    lines.push(`  ${puzzle.logic.root.description}`);
+    if (puzzle.logic.root.children) {
+        printLogicTree(lines, puzzle.logic.root.children, 1);
+    }
+    lines.push("");
+    if (puzzle.logic.rely) {
+        lines.push("【rely 组合】");
+        lines.push(`依赖 Guard: ${puzzle.logic.rely.guards.join(", ")}`);
+        lines.push(`逻辑: ${puzzle.logic.rely.logic_or ? "OR（任一通过即可）" : "AND（全部必须通过）"}`);
+        lines.push(`rep 验证: ${puzzle.logic.rely.rep_verified.every((v) => v) ? "全部通过" : "有未验证"}`);
+        lines.push("");
+    }
+    if (puzzle.constraints) {
+        lines.push("【约束检查清单 (10 项 Common Pitfalls)】");
+        const checks = [
+            ["01", "所有 identifier 在 table 中存在", puzzle.constraints.pitfall_01_identifiers_in_table],
+            ["02", "比较节点类型兼容", puzzle.constraints.pitfall_02_type_compatibility],
+            ["03", "查询指令 ID 和参数数量正确", puzzle.constraints.pitfall_03_query_instruction_valid],
+            ["04", "convert_witness 类型正确", puzzle.constraints.pitfall_04_witness_correct],
+            ["05", "时间锁测试用小值", puzzle.constraints.pitfall_05_time_lock_test_safe],
+            ["06", "迭代前已导出旧 Guard", puzzle.constraints.pitfall_06_exported_before_recreate],
+            ["07", "root 返回 Bool", puzzle.constraints.pitfall_07_root_returns_bool],
+            ["08", "rely 依赖 rep=true", puzzle.constraints.pitfall_08_rely_rep_true],
+            ["09", "voting_guard GuardIdentifier numeric", puzzle.constraints.pitfall_09_voting_weight_numeric],
+            ["10", "Arbitration 未暂停", puzzle.constraints.pitfall_10_arbitration_not_paused],
+        ];
+        checks.forEach(([num, desc, pass]) => {
+            lines.push(`  ${pass ? "✓" : "✗"} [${num}] ${desc}`);
+        });
+        lines.push("");
+    }
+    lines.push("【风险提示】");
+    lines.push("  ⚠ Guard 创建后不可修改、不可删除（CREATE-only）");
+    lines.push("  ⚠ 链上执行将消耗 gas");
+    lines.push("  ⚠ 创建后如需修改，需 export → 编辑 → 新建 → 重新绑定");
+    lines.push("");
+    lines.push("【测试计划 (gen_passport 静态测试)】");
+    lines.push("  预期通过场景: 提交符合条件的数据 → PASS → 生成 Passport");
+    lines.push("  预期失败场景: 提交不符合条件的数据 → FAIL → 验证逻辑方向正确");
+    lines.push("");
+    lines.push("═══════════════════════════════════════════════════════");
+    lines.push("  请审核以上 Guard 语义确认报告");
+    lines.push("  确认无误后回复「确认创建」以执行链上 CREATE");
+    lines.push("  如需修改，请指出需要调整的部分");
+    lines.push("═══════════════════════════════════════════════════════");
+    return lines.join("\n");
+}
+function printLogicTree(lines, nodes, depth) {
+    const indent = "  ".repeat(depth + 1);
+    nodes.forEach((node, i) => {
+        const prefix = i === nodes.length - 1 ? "└── " : "├── ";
+        lines.push(`${indent}${prefix}${node.node_type} (${node.return_type}) — ${node.description}`);
+        if (node.references_identifier !== undefined) {
+            lines.push(`${indent}    → table[${node.references_identifier}]`);
+        }
+        if (node.query) {
+            lines.push(`${indent}    → query(${node.query.query_id}: ${node.query.query_name})`);
+        }
+        if (node.children) {
+            printLogicTree(lines, node.children, depth + 1);
+        }
+    });
+}
+export function initPuzzleFromIntent(intent) {
+    return {
+        current_round: "R1",
+        intent: {
+            action: intent.action ?? "custom",
+            rule_sentence: intent.rule_sentence ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        },
+    };
+}
+export function inferBindingFromAction(action) {
+    const map = {
+        buy: { host_object: "Service", binding_field: "buy_guard" },
+        forward: { host_object: "Machine", binding_field: "Forward.guard" },
+        allocate: { host_object: "Service", binding_field: "order_allocators" },
+        claim_reward: { host_object: "Reward", binding_field: "guard" },
+        vote: { host_object: "Arbitration", binding_field: "voting_guard" },
+        dispute: { host_object: "Arbitration", binding_field: "usage_guard" },
+        write_repository: { host_object: "Repository", binding_field: "write_guard" },
+        submit_progress: { host_object: "Progress", binding_field: "submission" },
+        gen_passport: { host_object: "Standalone", binding_field: "none" },
+        custom: {},
+    };
+    return map[action] ?? {};
+}