@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/machine-confirm.js

@@ -0,0 +1,559 @@
+import { analyzeTopology, } from "./machine-topology.js";
+import { USER_DEFINED_PERM_INDEX_START, MAX_NODE_COUNT, MAX_NODE_PAIR_COUNT, MAX_FORWARD_COUNT, MAX_FORWARD_ORDER_COUNT, } from "./onchain-constants.js";
+import { assessMachineRisks, } from "./machine-risk.js";
+import { derivePuzzleFromMachineJson, generateConfirmationText, } from "./machine-puzzle.js";
+export const PUBLISH_CHECKLIST = [
+    {
+        id: "C-01",
+        description: "Entry point exists: at least one Pair with prev_node=''",
+        status: "skip",
+        detail: "Workflow cannot start without entry Pair. Verify Pair table for empty prev_node.",
+    },
+    {
+        id: "C-02",
+        description: "Every node has outgoing Forwards (except terminal nodes)",
+        status: "skip",
+        detail: "Dead-end nodes trap workflow. Identify terminals and verify they are intended.",
+    },
+    {
+        id: "C-03",
+        description: "Every node has incoming Pair (except entry point)",
+        status: "skip",
+        detail: "Orphaned nodes are unreachable. Verify all non-entry nodes are reachable.",
+    },
+    {
+        id: "C-04",
+        description: "All thresholds independently achievable (no dead branches)",
+        status: "skip",
+        detail: "If a competing Pair always loses, it is dead code. Use topology analysis.",
+    },
+    {
+        id: "C-05",
+        description: "All Guards exist on-chain and tested (via gen_passport)",
+        status: "skip",
+        detail: "Guard addresses referenced in forwards must be valid published Guard objects.",
+    },
+    {
+        id: "C-06",
+        description: "namedOperator vs permissionIndex correct per Forward",
+        status: "skip",
+        detail: "Each Forward must have at least one of namedOperator or permissionIndex.",
+    },
+    {
+        id: "C-07",
+        description: "Terminal nodes mapped to Allocator entries for fund distribution",
+        status: "skip",
+        detail: "Terminal nodes without Allocator risk funds being locked forever.",
+    },
+    {
+        id: "C-08",
+        description: "Tested end-to-end on testnet via a test Progress",
+        status: "skip",
+        detail: "Testnet verification is mandatory before mainnet publish.",
+    },
+    {
+        id: "C-09",
+        description: "Current state exported via machineNode2file as backup",
+        status: "skip",
+        detail: "Backup before publish. If publish fails, you can rebuild from export.",
+    },
+    {
+        id: "C-10",
+        description: `On-chain constraint limits respected (MAX_NODE_COUNT=${MAX_NODE_COUNT}, MAX_NODE_PAIR_COUNT=${MAX_NODE_PAIR_COUNT}, MAX_FORWARD_COUNT=${MAX_FORWARD_COUNT})`,
+        status: "skip",
+        detail: "Exceeding on-chain constants will cause transaction failure.",
+    },
+    {
+        id: "C-11",
+        description: "All permissionIndex values >= 1000 (USER_DEFINED_PERM_INDEX_START)",
+        status: "skip",
+        detail: "On-chain permission.move reserves indexes 0-999 for built-in permissions. " +
+            "Custom permission_index MUST be >= 1000 (see doc 06 §4.4). " +
+            "Using index < 1000 causes confusion with built-in permissions.",
+    },
+];
+export function runStaticChecklist(machine) {
+    const checked = [];
+    const failed = [];
+    const warnings = [];
+    const topology = analyzeTopology(machine.nodes, machine.pairs);
+    const hasEntry = topology.entry_nodes.length > 0;
+    checked.push({
+        id: "C-01",
+        description: "Entry point exists",
+        status: hasEntry ? "pass" : "fail",
+        detail: hasEntry
+            ? `Found entry nodes: ${topology.entry_nodes.join(", ")}`
+            : "NO entry Pair with prev_node=''",
+    });
+    if (!hasEntry)
+        failed.push(checked[checked.length - 1]);
+    const nonTerminalWithoutOutgoing = machine.nodes.filter((n) => !topology.terminal_nodes.includes(n.name) &&
+        !machine.pairs.some((p) => p.prev_node === n.name));
+    checked.push({
+        id: "C-02",
+        description: "Every node has outgoing Forwards (except terminals)",
+        status: nonTerminalWithoutOutgoing.length === 0 ? "pass" : "fail",
+        detail: nonTerminalWithoutOutgoing.length === 0
+            ? "All non-terminal nodes have outgoing Pairs"
+            : `Dead-end nodes: ${nonTerminalWithoutOutgoing.map((n) => n.name).join(", ")}`,
+    });
+    if (nonTerminalWithoutOutgoing.length > 0)
+        failed.push(checked[checked.length - 1]);
+    checked.push({
+        id: "C-03",
+        description: "Every node has incoming Pair",
+        status: topology.orphaned_nodes.length === 0 ? "pass" : "fail",
+        detail: topology.orphaned_nodes.length === 0
+            ? "All non-entry nodes are reachable"
+            : `Orphaned nodes: ${topology.orphaned_nodes.join(", ")}`,
+    });
+    if (topology.orphaned_nodes.length > 0)
+        failed.push(checked[checked.length - 1]);
+    checked.push({
+        id: "C-04",
+        description: "All thresholds achievable",
+        status: topology.dead_branches.length === 0 ? "pass" : "warning",
+        detail: topology.dead_branches.length === 0
+            ? "No dead branches detected"
+            : `Potential dead branches: ${topology.dead_branches.length}`,
+    });
+    if (topology.dead_branches.length > 0)
+        warnings.push(checked[checked.length - 1]);
+    checked.push({
+        id: "C-05",
+        description: "All Guards exist on-chain",
+        status: "skip",
+        detail: "Verify at runtime via onchain_objects query for each Guard address",
+    });
+    const invalidForwards = [];
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            const hasNamed = fwd.named_operator !== undefined;
+            const hasPerm = fwd.permission_index !== undefined;
+            if (!hasNamed && !hasPerm) {
+                invalidForwards.push(`${pair.prev_node}->${pair.next_node}:${fwd.name}`);
+            }
+        }
+    }
+    checked.push({
+        id: "C-06",
+        description: "Forward permission model correct",
+        status: invalidForwards.length === 0 ? "pass" : "fail",
+        detail: invalidForwards.length === 0
+            ? "All Forwards have valid permission"
+            : `Invalid Forwards: ${invalidForwards.join(", ")}`,
+    });
+    if (invalidForwards.length > 0)
+        failed.push(checked[checked.length - 1]);
+    checked.push({
+        id: "C-07",
+        description: "Terminal nodes have Allocator",
+        status: "skip",
+        detail: "Verify at Service binding stage",
+    });
+    checked.push({
+        id: "C-08",
+        description: "Testnet test passed",
+        status: "skip",
+        detail: "Verify at Layer 4 (environment)",
+    });
+    checked.push({
+        id: "C-09",
+        description: "machineNode2file backup created",
+        status: "skip",
+        detail: "Recommend exporting before publish",
+    });
+    const limitViolations = [];
+    if (!topology.within_limits.max_node_count)
+        limitViolations.push(`MAX_NODE_COUNT=${MAX_NODE_COUNT}`);
+    if (!topology.within_limits.max_node_pair_count)
+        limitViolations.push(`MAX_NODE_PAIR_COUNT=${MAX_NODE_PAIR_COUNT}`);
+    if (!topology.within_limits.max_forward_count)
+        limitViolations.push(`MAX_FORWARD_COUNT=${MAX_FORWARD_COUNT}`);
+    if (!topology.within_limits.max_forward_order_count)
+        limitViolations.push(`MAX_FORWARD_ORDER_COUNT=${MAX_FORWARD_ORDER_COUNT}`);
+    checked.push({
+        id: "C-10",
+        description: "On-chain limits respected",
+        status: limitViolations.length === 0 ? "pass" : "fail",
+        detail: limitViolations.length === 0
+            ? "All limits within bounds"
+            : `Violations: ${limitViolations.join(", ")}`,
+    });
+    if (limitViolations.length > 0)
+        failed.push(checked[checked.length - 1]);
+    const lowPermissionIndexes = [];
+    for (const pair of machine.pairs) {
+        for (const fwd of pair.forwards) {
+            if (fwd.permission_index !== undefined &&
+                fwd.permission_index !== null &&
+                fwd.permission_index < USER_DEFINED_PERM_INDEX_START) {
+                lowPermissionIndexes.push(`${pair.prev_node}->${pair.next_node}:${fwd.name} (idx=${fwd.permission_index})`);
+            }
+        }
+    }
+    checked.push({
+        id: "C-11",
+        description: `permissionIndex >= ${USER_DEFINED_PERM_INDEX_START}`,
+        status: lowPermissionIndexes.length === 0 ? "pass" : "fail",
+        detail: lowPermissionIndexes.length === 0
+            ? `All permission_index values >= ${USER_DEFINED_PERM_INDEX_START}`
+            : `permission_index < ${USER_DEFINED_PERM_INDEX_START}: ${lowPermissionIndexes.join(", ")}`,
+    });
+    if (lowPermissionIndexes.length > 0)
+        failed.push(checked[checked.length - 1]);
+    return {
+        passed: failed.length === 0,
+        checked_items: checked,
+        failed_items: failed,
+        warnings,
+    };
+}
+export function integrateRiskAssessment(machine, context) {
+    const machineForRisk = {
+        nodes: machine.nodes,
+        pairs: machine.pairs,
+        b_published: machine.b_published,
+        b_paused: machine.b_paused,
+        scene_id: machine.scene_id,
+    };
+    const assessment = assessMachineRisks(machineForRisk, context);
+    const blocking_risks = [];
+    const warning_risks = [];
+    for (const risk of assessment.detected_risks) {
+        if (risk.severity === "critical" || risk.severity === "high") {
+            blocking_risks.push(risk.rule_id);
+        }
+        else if (risk.severity === "medium") {
+            warning_risks.push(risk.rule_id);
+        }
+    }
+    let recommendation;
+    if (blocking_risks.some((id) => {
+        const risk = assessment.detected_risks.find((r) => r.rule_id === id);
+        return risk?.severity === "critical";
+    })) {
+        recommendation = "do_not_publish";
+    }
+    else if (blocking_risks.length > 0) {
+        recommendation = "fix_first";
+    }
+    else if (warning_risks.length > 3) {
+        recommendation = "fix_first";
+    }
+    else {
+        recommendation = "publish";
+    }
+    return {
+        overall_risk_level: assessment.overall_level,
+        blocking_risks,
+        warning_risks,
+        recommendation,
+    };
+}
+export const CONFIRMATION_QUESTIONS = [
+    { id: "Q1", question: "Reviewed topology and confirmed all nodes/forwards are correct?", expected_response: "yes", blocking: true },
+    { id: "Q2", question: "Tested this Machine on TESTNET with a successful Progress run?", expected_response: "yes", blocking: true },
+    { id: "Q3", question: "All Guards created, bound, and verified via gen_passport?", expected_response: "yes", blocking: true },
+    { id: "Q4", question: "All Allocators configured for terminal nodes?", expected_response: "yes", blocking: true },
+    { id: "Q5", question: "Acknowledge that publishing is IRREVERSIBLE and gas will be consumed?", expected_response: "yes", blocking: true },
+    { id: "Q6", question: "Proceed with publishing this Machine NOW?", expected_response: "yes", blocking: true },
+];
+export function parseUserConfirmation(userInput) {
+    const responses = userInput.split(",").map((s) => s.trim().toLowerCase());
+    const user_responses = [];
+    for (let i = 0; i < CONFIRMATION_QUESTIONS.length; i++) {
+        const q = CONFIRMATION_QUESTIONS[i];
+        const answer = responses[i] || "(no answer)";
+        const is_yes = answer.startsWith("y") || answer === "yes";
+        const is_no = answer.startsWith("n") || answer === "no";
+        user_responses.push({
+            question_id: q.id,
+            response: is_yes ? "yes" : is_no ? "no" : "unclear",
+            raw_input: answer,
+        });
+    }
+    const all_blocking_yes = CONFIRMATION_QUESTIONS
+        .filter((q) => q.blocking)
+        .every((q, idx) => user_responses[idx].response === "yes");
+    return {
+        questions_asked: CONFIRMATION_QUESTIONS,
+        user_responses,
+        approved: all_blocking_yes,
+        declined_reason: all_blocking_yes
+            ? undefined
+            : "One or more blocking questions answered 'no'",
+        timestamp: new Date().toISOString(),
+    };
+}
+export function generateFullConfirmationText(machine, checklistResult, riskResult) {
+    const puzzle = derivePuzzleFromMachineJson({
+        nodes: machine.nodes,
+        pairs: machine.pairs,
+        scene_id: machine.scene_id,
+        template_id: machine.template_id,
+    });
+    const puzzleText = generateConfirmationText(puzzle);
+    const lines = [
+        "╔═══════════════════════════════════════════════════════════════╗",
+        "║           MACHINE PUBLISH CONFIRMATION REQUIRED                ║",
+        "╚═══════════════════════════════════════════════════════════════╝",
+        "",
+        "⚠️  WARNING: Publishing a Machine is IRREVERSIBLE.",
+        "   - Nodes, Pairs, Forwards will be FROZEN permanently.",
+        "   - Gas will be consumed (cannot be refunded).",
+        "   - Any error requires creating a NEW Machine (with new gas cost).",
+        "",
+        "═══════════════════════════════════════════════════════════════",
+        puzzleText,
+        "═══════════════════════════════════════════════════════════════",
+        "RISK ASSESSMENT:",
+        `  Overall Risk Level: ${riskResult.overall_risk_level.toUpperCase()}`,
+        `  Recommendation:     ${riskResult.recommendation}`,
+        `  Blocking Risks:     ${riskResult.blocking_risks.length === 0 ? "None" : riskResult.blocking_risks.join(", ")}`,
+        `  Warning Risks:     ${riskResult.warning_risks.length === 0 ? "None" : riskResult.warning_risks.join(", ")}`,
+        "",
+        "═══════════════════════════════════════════════════════════════",
+        "STATIC CHECKLIST:",
+        `  Passed:    ${checklistResult.checked_items.filter((i) => i.status === "pass").length} / ${checklistResult.checked_items.length}`,
+        `  Failed:    ${checklistResult.failed_items.length}`,
+        `  Warnings:  ${checklistResult.warnings.length}`,
+        `  Skipped:   ${checklistResult.checked_items.filter((i) => i.status === "skip").length}`,
+        "",
+        ...checklistResult.failed_items.map((i) => `  ❌ ${i.id}: ${i.description} — ${i.detail || ""}`),
+        ...checklistResult.warnings.map((i) => `  ⚠️  ${i.id}: ${i.description} — ${i.detail || ""}`),
+        "",
+        "═══════════════════════════════════════════════════════════════",
+        "USER CONFIRMATION QUESTIONS:",
+        "",
+        ...CONFIRMATION_QUESTIONS.map((q, idx) => `  Q${idx + 1}. ${q.question} [Yes / No]`),
+        "",
+        "If you answer 'No' to ANY of Q1-Q5, publish will be BLOCKED.",
+        "If you answer 'No' to Q6, publish will be CANCELLED (no gas spent).",
+        "",
+        "Type your answers (Q1-Q6) separated by commas:",
+    ];
+    return lines.join("\n");
+}
+export function verifyEnvironment(machine, context, isMainnet) {
+    const missing_dependencies = [];
+    for (const pair of machine.pairs) {
+        for (const forward of pair.forwards) {
+            if (forward.guard && !context.published_guards.has(forward.guard)) {
+                missing_dependencies.push(`Guard: ${forward.guard}`);
+            }
+        }
+    }
+    const has_testnet_test_passed = context.testnet_test_passed;
+    const effectiveTestPassed = isMainnet ? has_testnet_test_passed : true;
+    return {
+        is_testnet: !isMainnet,
+        has_testnet_test_passed: effectiveTestPassed,
+        gas_estimation: context.gas_estimation,
+        dependency_table_complete: missing_dependencies.length === 0,
+        missing_dependencies,
+    };
+}
+function hashMachineJson(machine) {
+    const json = JSON.stringify({
+        nodes: machine.nodes.map((n) => n.name),
+        pairs: machine.pairs.map((p) => ({
+            prev: p.prev_node,
+            next: p.next_node,
+            threshold: p.threshold,
+            forwards: p.forwards.map((f) => f.name),
+        })),
+    });
+    let hash = 0;
+    for (let i = 0; i < json.length; i++) {
+        const char = json.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return `0x${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+export function confirmPublish(machine, context, isMainnet, userConfirmationInput) {
+    const decision_record = {
+        timestamp: new Date().toISOString(),
+        user_address: context.user_address,
+        machine_json_hash: hashMachineJson(machine),
+        template_id: machine.template_id,
+        scene_id: machine.scene_id,
+        final_status: "blocked_checklist",
+    };
+    const checklist_result = runStaticChecklist(machine);
+    if (!checklist_result.passed) {
+        return {
+            status: "blocked_checklist",
+            checklist_result,
+            decision_record: { ...decision_record, final_status: "blocked_checklist" },
+            block_reason: `Checklist failed: ${checklist_result.failed_items.map((i) => i.id).join(", ")}`,
+        };
+    }
+    const risk_result = integrateRiskAssessment(machine, context);
+    if (risk_result.recommendation === "do_not_publish") {
+        return {
+            status: "blocked_risk",
+            checklist_result,
+            risk_result,
+            decision_record: { ...decision_record, final_status: "blocked_risk" },
+            block_reason: `Critical risks detected: ${risk_result.blocking_risks.join(", ")}`,
+        };
+    }
+    if (!userConfirmationInput) {
+        const confirmation_text = generateFullConfirmationText(machine, checklist_result, risk_result);
+        return {
+            status: "blocked_user",
+            checklist_result,
+            risk_result,
+            confirmation_text,
+            decision_record: { ...decision_record, final_status: "blocked_user" },
+            block_reason: "Awaiting user confirmation",
+        };
+    }
+    const user_confirmation = parseUserConfirmation(userConfirmationInput);
+    if (!user_confirmation.approved) {
+        return {
+            status: "blocked_user",
+            checklist_result,
+            risk_result,
+            user_confirmation,
+            decision_record: { ...decision_record, final_status: "blocked_user" },
+            block_reason: user_confirmation.declined_reason || "User declined",
+        };
+    }
+    const environment_result = verifyEnvironment(machine, context, isMainnet);
+    if (!environment_result.dependency_table_complete || !environment_result.has_testnet_test_passed) {
+        const issues = [];
+        if (!environment_result.dependency_table_complete) {
+            issues.push(`missing dependencies: ${environment_result.missing_dependencies.join(", ")}`);
+        }
+        if (!environment_result.has_testnet_test_passed) {
+            issues.push("testnet test not passed (required for mainnet)");
+        }
+        return {
+            status: "blocked_environment",
+            checklist_result,
+            risk_result,
+            user_confirmation,
+            environment_result,
+            decision_record: { ...decision_record, final_status: "blocked_environment" },
+            block_reason: `Environment issues: ${issues.join("; ")}`,
+        };
+    }
+    return {
+        status: "approved",
+        checklist_result,
+        risk_result,
+        user_confirmation,
+        environment_result,
+        decision_record: { ...decision_record, final_status: "approved" },
+    };
+}
+export function overrideBlockWithReason(result, _userReason) {
+    if (result.status !== "blocked_risk") {
+        return result;
+    }
+    const hasCritical = result.risk_result?.blocking_risks.some((id) => id.includes("CRITICAL") || id.includes("critical"));
+    if (hasCritical) {
+        return {
+            ...result,
+            block_reason: "Cannot override CRITICAL risks",
+        };
+    }
+    return {
+        ...result,
+        status: "approved",
+        block_reason: undefined,
+        decision_record: {
+            ...result.decision_record,
+            final_status: "approved",
+        },
+    };
+}
+export function progressiveCheck(machine, round) {
+    const fullResult = runStaticChecklist(machine);
+    if (round === "R5") {
+        return filterChecklist(fullResult, ["C-01", "C-02", "C-03", "C-04", "C-06", "C-10"]);
+    }
+    if (round === "R6") {
+        return filterChecklist(fullResult, ["C-01", "C-02", "C-03", "C-04", "C-05", "C-06", "C-10"]);
+    }
+    return fullResult;
+}
+function filterChecklist(result, allowedIds) {
+    const filtered = result.checked_items.filter((i) => allowedIds.includes(i.id));
+    return {
+        passed: filtered.filter((i) => i.status === "fail").length === 0,
+        checked_items: filtered,
+        failed_items: filtered.filter((i) => i.status === "fail"),
+        warnings: filtered.filter((i) => i.status === "warning"),
+    };
+}
+export function prePublishHook(machine, context, isMainnet) {
+    const result = confirmPublish(machine, context, isMainnet);
+    if (result.status !== "blocked_user" && result.status !== "approved") {
+        return {
+            proceed: false,
+            error: formatBlockError(result),
+            confirmGateResult: result,
+        };
+    }
+    if (result.status === "blocked_user" && result.confirmation_text) {
+        return {
+            proceed: false,
+            error: result.confirmation_text,
+            confirmGateResult: result,
+        };
+    }
+    return { proceed: true, confirmGateResult: result };
+}
+export function postConfirmationHook(machine, context, isMainnet, userConfirmationInput) {
+    const result = confirmPublish(machine, context, isMainnet, userConfirmationInput);
+    if (result.status !== "approved") {
+        return {
+            proceed: false,
+            error: formatBlockError(result),
+            confirmGateResult: result,
+        };
+    }
+    return { proceed: true, confirmGateResult: result };
+}
+export function formatBlockError(result) {
+    const lines = [
+        "❌ MACHINE PUBLISH BLOCKED",
+        "",
+        `Status: ${result.status}`,
+        `Reason: ${result.block_reason || "(no reason provided)"}`,
+        "",
+    ];
+    if (result.status === "blocked_checklist") {
+        lines.push("Failed checklist items:");
+        for (const item of result.checklist_result.failed_items) {
+            lines.push(`  - ${item.id}: ${item.description}`);
+            lines.push(`    Detail: ${item.detail || "(no detail)"}`);
+        }
+    }
+    if (result.status === "blocked_risk" && result.risk_result) {
+        lines.push("Blocking risks:");
+        for (const riskId of result.risk_result.blocking_risks) {
+            lines.push(`  - ${riskId}`);
+        }
+        lines.push("");
+        lines.push(`Recommendation: ${result.risk_result.recommendation}`);
+    }
+    if (result.status === "blocked_environment" && result.environment_result) {
+        lines.push("Environment issues:");
+        for (const dep of result.environment_result.missing_dependencies) {
+            lines.push(`  - Missing dependency: ${dep}`);
+        }
+        if (!result.environment_result.has_testnet_test_passed) {
+            lines.push("  - Testnet test NOT passed (required for mainnet)");
+        }
+    }
+    return lines.join("\n");
+}
+export const MACHINE_CONFIRM_VERSION = "1.0.0";
+export const MACHINE_CHECKLIST_ITEMS_COUNT = PUBLISH_CHECKLIST.length;
+export const MACHINE_CONFIRMATION_QUESTIONS_COUNT = CONFIRMATION_QUESTIONS.length;