@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/service-confirm.js

@@ -0,0 +1,699 @@
+import { MAX_SALE_COUNT, MAX_REPOSITORY_COUNT, MAX_ARBITRATION_COUNT, MAX_DISCOUNT_COUNT_ONCE, MAX_DISCOUNT_TOTAL_COUNT, MAX_WIP_LENGTH, MAX_WIP_HASH_LENGTH, } from "@wowok/wowok";
+import { assessServiceRisks, } from "./service-risk.js";
+export const SERVICE_PUBLISH_CHECKLIST = [
+    { id: "C-S-01", description: "Sales count <= MAX_SALE_COUNT (50)", passed: false, message: "" },
+    { id: "C-S-02", description: "Repositories count <= MAX_REPOSITORY_COUNT (100)", passed: false, message: "" },
+    { id: "C-S-03", description: "Arbitrations count <= MAX_ARBITRATION_COUNT (20)", passed: false, message: "" },
+    { id: "C-S-04", description: "Rewards count <= MAX_REWARD_COUNT (20)", passed: false, message: "" },
+    { id: "C-S-05", description: "WIP URL length <= MAX_WIP_LENGTH (1024) for each sale", passed: false, message: "" },
+    { id: "C-S-06", description: "WIP hash length <= MAX_WIP_HASH_LENGTH (64) — sha256 hex", passed: false, message: "" },
+    { id: "C-S-07", description: "WIP hash NOT empty when wip URL is set (tamper protection)", passed: false, message: "" },
+    { id: "C-S-08", description: "Discount count <= MAX_DISCOUNT_TOTAL_COUNT (20000)", passed: false, message: "" },
+    { id: "C-S-09", description: "Discount per-call <= MAX_DISCOUNT_COUNT_ONCE (1000)", passed: false, message: "" },
+    { id: "C-S-10", description: "Publish: order_allocators MUST be set (F-S-18, E_NO_ALLOCATOR)", passed: false, message: "" },
+    { id: "C-S-11", description: "Publish: if compensation_fund > 0, arbitrations non-empty (F-S-19)", passed: false, message: "" },
+    { id: "C-S-12", description: "Post-publish: machine modification BLOCKED (F-S-20)", passed: false, message: "" },
+    { id: "C-S-13", description: "Post-publish: arbitrations modification BLOCKED (F-S-21)", passed: false, message: "" },
+    { id: "C-S-14", description: "Post-publish: order_allocators modification BLOCKED (F-S-22)", passed: false, message: "" },
+    { id: "C-S-15", description: "compensation_fund_withdraw requires bPaused=true + lock_duration expired (F-S-25, F-S-26)", passed: false, message: "" },
+    { id: "C-S-16", description: "Address fields valid (0x prefix, length >= 40)", passed: false, message: "" },
+    { id: "C-S-17", description: "Publish operation double-confirmed (bPublished irreversible)", passed: false, message: "" },
+    { id: "C-S-18", description: "Ownership transfer double-confirmed (IRREVERSIBLE)", passed: false, message: "" },
+];
+function runStaticChecklist(input) {
+    const items = SERVICE_PUBLISH_CHECKLIST.map(c => ({ ...c }));
+    const data = input.service_json;
+    const isPublished = input.current_bPublished ?? false;
+    if (data.sales && (data.sales.op === "add" || data.sales.op === "set")) {
+        const currentCount = input.current_sales_count ?? 0;
+        const newCount = data.sales.op === "set"
+            ? data.sales.sales.length
+            : currentCount + data.sales.sales.length;
+        const cs01 = items.find(i => i.id === "C-S-01");
+        cs01.passed = newCount <= MAX_SALE_COUNT;
+        cs01.message = cs01.passed ? "" : `sales count ${newCount} > ${MAX_SALE_COUNT}`;
+    }
+    else {
+        items.find(i => i.id === "C-S-01").passed = true;
+    }
+    if (data.repositories && (data.repositories.op === "add" || data.repositories.op === "set")) {
+        const currentCount = input.current_repositories_count ?? 0;
+        const newCount = data.repositories.op === "set"
+            ? data.repositories.objects.length
+            : currentCount + data.repositories.objects.length;
+        const cs02 = items.find(i => i.id === "C-S-02");
+        cs02.passed = newCount <= MAX_REPOSITORY_COUNT;
+        cs02.message = cs02.passed ? "" : `repositories count ${newCount} > ${MAX_REPOSITORY_COUNT}`;
+    }
+    else {
+        items.find(i => i.id === "C-S-02").passed = true;
+    }
+    if (data.arbitrations && (data.arbitrations.op === "add" || data.arbitrations.op === "set")) {
+        const currentCount = input.current_arbitrations_count ?? 0;
+        const newCount = data.arbitrations.op === "set"
+            ? data.arbitrations.objects.length
+            : currentCount + data.arbitrations.objects.length;
+        const cs03 = items.find(i => i.id === "C-S-03");
+        cs03.passed = newCount <= MAX_ARBITRATION_COUNT;
+        cs03.message = cs03.passed ? "" : `arbitrations count ${newCount} > ${MAX_ARBITRATION_COUNT}`;
+    }
+    else {
+        items.find(i => i.id === "C-S-03").passed = true;
+    }
+    if (data.rewards && (data.rewards.op === "add" || data.rewards.op === "set")) {
+        const currentCount = input.current_rewards_count ?? 0;
+        const newCount = data.rewards.op === "set"
+            ? data.rewards.objects.length
+            : currentCount + data.rewards.objects.length;
+        const cs04 = items.find(i => i.id === "C-S-04");
+        cs04.passed = newCount <= 20;
+        cs04.message = cs04.passed ? "" : `rewards count ${newCount} > 20`;
+    }
+    else {
+        items.find(i => i.id === "C-S-04").passed = true;
+    }
+    if (data.sales && (data.sales.op === "add" || data.sales.op === "set")) {
+        let urlOk = true, hashLenOk = true, hashNotEmptyOk = true;
+        let urlMsg = "", hashLenMsg = "", hashEmptyMsg = "";
+        for (const s of data.sales.sales) {
+            if (s.wip && s.wip.length > MAX_WIP_LENGTH) {
+                urlOk = false;
+                urlMsg = `sale "${s.name}" wip URL length ${s.wip.length} > ${MAX_WIP_LENGTH}`;
+                break;
+            }
+            if (s.wip_hash && s.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+                hashLenOk = false;
+                hashLenMsg = `sale "${s.name}" wip_hash length ${s.wip_hash.length} > ${MAX_WIP_HASH_LENGTH}`;
+                break;
+            }
+            if (s.wip && !s.wip_hash) {
+                hashNotEmptyOk = false;
+                hashEmptyMsg = `sale "${s.name}" has wip URL but no wip_hash (tamper risk)`;
+                break;
+            }
+        }
+        const cs05 = items.find(i => i.id === "C-S-05");
+        cs05.passed = urlOk;
+        cs05.message = urlMsg;
+        const cs06 = items.find(i => i.id === "C-S-06");
+        cs06.passed = hashLenOk;
+        cs06.message = hashLenMsg;
+        const cs07 = items.find(i => i.id === "C-S-07");
+        cs07.passed = hashNotEmptyOk;
+        cs07.message = hashEmptyMsg;
+    }
+    else {
+        items.find(i => i.id === "C-S-05").passed = true;
+        items.find(i => i.id === "C-S-06").passed = true;
+        items.find(i => i.id === "C-S-07").passed = true;
+    }
+    if (data.discount) {
+        const total = data.discount.count;
+        const cs08 = items.find(i => i.id === "C-S-08");
+        cs08.passed = total <= MAX_DISCOUNT_TOTAL_COUNT;
+        cs08.message = cs08.passed ? "" : `discount total count ${total} > ${MAX_DISCOUNT_TOTAL_COUNT}`;
+        const cs09 = items.find(i => i.id === "C-S-09");
+        cs09.passed = total <= MAX_DISCOUNT_COUNT_ONCE;
+        cs09.message = cs09.passed ? "" : `discount per-call count ${total} > ${MAX_DISCOUNT_COUNT_ONCE}`;
+    }
+    else {
+        items.find(i => i.id === "C-S-08").passed = true;
+        items.find(i => i.id === "C-S-09").passed = true;
+    }
+    if (data.publish) {
+        const hasAllocators = input.current_order_allocators_set === true || data.order_allocators !== undefined;
+        const cs10 = items.find(i => i.id === "C-S-10");
+        cs10.passed = hasAllocators;
+        cs10.message = hasAllocators ? "" : "publish requires order_allocators (F-S-18, E_NO_ALLOCATOR)";
+    }
+    else {
+        items.find(i => i.id === "C-S-10").passed = true;
+    }
+    if (data.publish) {
+        const compBalance = input.current_compensation_fund_balance ?? "0";
+        const arbCount = input.current_arbitrations_count ?? 0;
+        const hasArbFromInput = data.arbitrations && "objects" in data.arbitrations ? data.arbitrations.objects.length : 0;
+        const totalArb = arbCount + hasArbFromInput;
+        const cs11 = items.find(i => i.id === "C-S-11");
+        if (BigInt(compBalance) > 0n && totalArb === 0) {
+            cs11.passed = false;
+            cs11.message = `compensation_fund ${compBalance} > 0 but no arbitrations (F-S-19)`;
+        }
+        else {
+            cs11.passed = true;
+        }
+    }
+    else {
+        items.find(i => i.id === "C-S-11").passed = true;
+    }
+    if (isPublished && data.machine !== undefined) {
+        const cs12 = items.find(i => i.id === "C-S-12");
+        cs12.passed = false;
+        cs12.message = "machine is IMMUTABLE post-publish (F-S-20)";
+    }
+    else {
+        items.find(i => i.id === "C-S-12").passed = true;
+    }
+    if (isPublished && data.arbitrations !== undefined) {
+        const cs13 = items.find(i => i.id === "C-S-13");
+        cs13.passed = false;
+        cs13.message = "arbitrations is IMMUTABLE post-publish (F-S-21)";
+    }
+    else {
+        items.find(i => i.id === "C-S-13").passed = true;
+    }
+    if (isPublished && data.order_allocators !== undefined) {
+        const cs14 = items.find(i => i.id === "C-S-14");
+        cs14.passed = false;
+        cs14.message = "order_allocators is IMMUTABLE post-publish (F-S-22)";
+    }
+    else {
+        items.find(i => i.id === "C-S-14").passed = true;
+    }
+    if (data.compensation_fund_withdraw) {
+        const paused = input.current_bPaused ?? false;
+        const cs15 = items.find(i => i.id === "C-S-15");
+        if (!paused) {
+            cs15.passed = false;
+            cs15.message = "compensation_fund_withdraw requires bPaused=true (F-S-26)";
+        }
+        else {
+            cs15.passed = true;
+            cs15.message = "Paused OK — verify lock_duration expired on-chain";
+        }
+    }
+    else {
+        items.find(i => i.id === "C-S-15").passed = true;
+    }
+    const addresses = [];
+    if (data.object)
+        addresses.push(data.object);
+    if (data.machine)
+        addresses.push(data.machine);
+    if (data.buy_guard)
+        addresses.push(data.buy_guard);
+    if (data.arbitrations && "objects" in data.arbitrations)
+        addresses.push(...data.arbitrations.objects);
+    if (data.repositories && "objects" in data.repositories)
+        addresses.push(...data.repositories.objects);
+    if (data.rewards && "objects" in data.rewards)
+        addresses.push(...data.rewards.objects);
+    if (data.builder)
+        addresses.push(data.builder);
+    if (data.um)
+        addresses.push(data.um);
+    const cs16 = items.find(i => i.id === "C-S-16");
+    if (addresses.length === 0) {
+        cs16.passed = true;
+    }
+    else {
+        const invalid = addresses.filter(a => !a.startsWith("0x") || a.length < 40);
+        cs16.passed = invalid.length === 0;
+        cs16.message = invalid.length === 0 ? "" : `Invalid addresses: ${invalid.slice(0, 3).join(", ")}${invalid.length > 3 ? "..." : ""}`;
+    }
+    if (data.publish) {
+        const cs17 = items.find(i => i.id === "C-S-17");
+        cs17.passed = false;
+        cs17.message = "Pending user confirmation in Layer 3 (QS1)";
+    }
+    else {
+        items.find(i => i.id === "C-S-17").passed = true;
+    }
+    if (data.builder) {
+        const cs18 = items.find(i => i.id === "C-S-18");
+        cs18.passed = false;
+        cs18.message = "Pending user confirmation in Layer 3 (QS2)";
+    }
+    else {
+        items.find(i => i.id === "C-S-18").passed = true;
+    }
+    const allPassed = items.filter(i => i.id !== "C-S-17" && i.id !== "C-S-18").every(i => i.passed);
+    return { all_passed: allPassed, items };
+}
+function adaptRiskAssessment(input) {
+    const ctx = {
+        object: input.service_json.object,
+        description: input.service_json.description,
+        location: input.service_json.location,
+        sales: input.service_json.sales,
+        repositories: input.service_json.repositories,
+        rewards: input.service_json.rewards,
+        arbitrations: input.service_json.arbitrations,
+        machine: input.service_json.machine,
+        discount: input.service_json.discount,
+        customer_required: input.service_json.customer_required,
+        order_allocators: input.service_json.order_allocators,
+        buy_guard: input.service_json.buy_guard,
+        compensation_fund_add: input.service_json.compensation_fund_add,
+        setting_locked_time_add: input.service_json.setting_locked_time_add,
+        compensation_fund_receive: input.service_json.compensation_fund_receive,
+        owner_receive: input.service_json.owner_receive,
+        pause: input.service_json.pause,
+        publish: input.service_json.publish,
+        um: input.service_json.um,
+        order_new: input.service_json.order_new,
+        current_bPublished: input.current_bPublished,
+        current_bPaused: input.current_bPaused,
+        current_compensation_fund_balance: input.current_compensation_fund_balance,
+        current_setting_lock_duration: input.current_setting_lock_duration,
+        current_arbitrations_count: input.current_arbitrations_count,
+        current_rewards_count: input.current_rewards_count,
+        current_repositories_count: input.current_repositories_count,
+        current_sales_count: input.current_sales_count,
+        current_machine_bound: input.current_machine_bound,
+        current_order_allocators_set: input.current_order_allocators_set,
+        builder: input.service_json.builder,
+        target_objects_types: input.target_objects_types,
+    };
+    return assessServiceRisks(ctx);
+}
+export const SERVICE_CONFIRMATION_QUESTIONS = [
+    {
+        id: "QS1",
+        question: "⚠️ PUBLISH is IRREVERSIBLE — once published, machine/arbitrations/order_allocators become permanently immutable. Do you confirm all configurations are correct and you're ready to publish?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-3-01", "R-S-4-01"],
+    },
+    {
+        id: "QS2",
+        question: "⚠️ Ownership transfer is IRREVERSIBLE — original owner will lose ALL control over the Service, including compensation_fund and all bindings. Do you confirm the new owner address is correct?",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-3-04"],
+    },
+    {
+        id: "QS3",
+        question: "Are all sales items configured with valid wip_hash (sha256 of the WIP file content)? Missing or incorrect hashes create tampering risks.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-2-01"],
+    },
+    {
+        id: "QS4",
+        question: "If publishing with compensation_fund > 0, are Arbitration objects configured and their reputations verified? Owners cannot add new Arbitration objects post-publish.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-5-02"],
+    },
+    {
+        id: "QS5",
+        question: "Is the order_allocators configuration final? It becomes PERMANENTLY immutable after publish — fee splits cannot be adjusted without creating a new Service.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-5-03", "R-S-4-03"],
+    },
+    {
+        id: "QS6",
+        question: "If binding a Machine, is it published and verified? Machine binding is permanent post-publish — Progress objects will inherit this Machine forever.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-5-01"],
+    },
+    {
+        id: "QS7",
+        question: "If using buy_guard, is the Guard configuration appropriate for your sale phase (whitelist for pre-sale, null for public sale)? buy_guard remains mutable post-publish.",
+        requires_explicit_yes: false,
+        related_risk_ids: ["R-S-3-03"],
+    },
+    {
+        id: "QS8",
+        question: "For discount operations: are discount counts within limits (<=1000 per call, <=20000 total)? Expired or exhausted discounts cannot be re-issued.",
+        requires_explicit_yes: false,
+        related_risk_ids: ["R-S-2-04"],
+    },
+    {
+        id: "QS9",
+        question: "For order placement: are you aware that stock is deducted at the quote stage and NOT rolled back if later stages fail? Monitor failed transactions and re-add stock manually if needed.",
+        requires_explicit_yes: true,
+        related_risk_ids: ["R-S-2-03"],
+    },
+    {
+        id: "QS10",
+        question: "Have you exported the current Service JSON as a backup before this operation?",
+        requires_explicit_yes: false,
+    },
+];
+function processUserConfirmation(input, assessment) {
+    const questions = [...SERVICE_CONFIRMATION_QUESTIONS];
+    const data = input.service_json;
+    const irrelevant = [];
+    if (!data.publish)
+        irrelevant.push("QS1");
+    if (!data.builder)
+        irrelevant.push("QS2");
+    if (!data.sales || data.sales.op === "clear" || data.sales.op === "remove")
+        irrelevant.push("QS3");
+    if (!data.publish && !(data.compensation_fund_add && BigInt(String(data.compensation_fund_add.balance)) > 0n))
+        irrelevant.push("QS4");
+    if (!data.publish && !data.order_allocators)
+        irrelevant.push("QS5");
+    if (!data.machine)
+        irrelevant.push("QS6");
+    if (data.buy_guard === undefined)
+        irrelevant.push("QS7");
+    if (!data.discount)
+        irrelevant.push("QS8");
+    if (!data.order_new)
+        irrelevant.push("QS9");
+    const filtered = questions.filter(q => !irrelevant.includes(q.id));
+    if (input.skip_user_confirmation) {
+        return {
+            questions_asked: filtered,
+            responses: filtered.map(q => ({ question_id: q.id, response: "yes" })),
+            all_confirmed: true,
+        };
+    }
+    return {
+        questions_asked: filtered,
+        responses: [],
+        all_confirmed: false,
+    };
+}
+function verifyEnvironment(input) {
+    const checks = [];
+    const data = input.service_json;
+    if (data.object) {
+        checks.push({
+            name: "object_exists",
+            passed: true,
+            message: `Service object ${data.object} assumed to exist`,
+        });
+    }
+    if (data.publish) {
+        checks.push({
+            name: "signer_has_publish_permission",
+            passed: true,
+            message: "Signer must hold SERVICE_PUBLISH (311) permission",
+        });
+    }
+    if (data.builder) {
+        checks.push({
+            name: "signer_is_owner",
+            passed: true,
+            message: "Signer must be Service owner for transfer (builder)",
+        });
+    }
+    if (data.pause !== undefined) {
+        checks.push({
+            name: "signer_has_pause_permission",
+            passed: true,
+            message: "Signer must hold SERVICE_PAUSE (310) permission",
+        });
+    }
+    if (data.publish) {
+        if (!input.current_order_allocators_set && data.order_allocators === undefined) {
+            checks.push({
+                name: "order_allocators_set",
+                passed: false,
+                message: "Publish blocked: order_allocators not set (E_NO_ALLOCATOR)",
+            });
+        }
+        const compBalance = input.current_compensation_fund_balance ?? "0";
+        const arbCount = input.current_arbitrations_count ?? 0;
+        const arbFromInput = data.arbitrations && "objects" in data.arbitrations ? data.arbitrations.objects.length : 0;
+        if (BigInt(compBalance) > 0n && (arbCount + arbFromInput) === 0) {
+            checks.push({
+                name: "arbitrations_for_compensation_fund",
+                passed: false,
+                message: "Publish blocked: compensation_fund > 0 but no arbitrations (E_ARBITRATION_NOT_SET_WITH_COMPENSATION_FUND)",
+            });
+        }
+    }
+    if (input.current_bPublished) {
+        if (data.machine !== undefined) {
+            checks.push({
+                name: "machine_immutable_post_publish",
+                passed: false,
+                message: "machine cannot be modified post-publish (F-S-20)",
+            });
+        }
+        if (data.arbitrations !== undefined) {
+            checks.push({
+                name: "arbitrations_immutable_post_publish",
+                passed: false,
+                message: "arbitrations cannot be modified post-publish (F-S-21)",
+            });
+        }
+        if (data.order_allocators !== undefined) {
+            checks.push({
+                name: "order_allocators_immutable_post_publish",
+                passed: false,
+                message: "order_allocators cannot be modified post-publish (F-S-22)",
+            });
+        }
+    }
+    if (data.compensation_fund_withdraw && !input.current_bPaused) {
+        checks.push({
+            name: "compensation_fund_withdraw_requires_paused",
+            passed: false,
+            message: "compensation_fund_withdraw requires bPaused=true (F-S-26)",
+        });
+    }
+    const allPassed = checks.every(c => c.passed);
+    return { passed: allPassed, checks };
+}
+export const SERVICE_CONFIRM_VERSION = "1.0.0";
+export function runServiceConfirmGate(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 && i.id !== "C-S-17" && i.id !== "C-S-18").map(i => i.id).join(", ")}`,
+            decision_record: {
+                timestamp: new Date().toISOString(),
+                gate_version: SERVICE_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: SERVICE_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.service_json.publish) {
+            const cs17 = checklist.items.find(i => i.id === "C-S-17");
+            if (cs17) {
+                const qs1 = userConf.responses.find(r => r.question_id === "QS1");
+                cs17.passed = qs1?.response === "yes";
+                cs17.message = cs17.passed ? "" : "Publish not confirmed by user (QS1)";
+            }
+        }
+        if (input.service_json.builder) {
+            const cs18 = checklist.items.find(i => i.id === "C-S-18");
+            if (cs18) {
+                const qs2 = userConf.responses.find(r => r.question_id === "QS2");
+                cs18.passed = qs2?.response === "yes";
+                cs18.message = cs18.passed ? "" : "Transfer not confirmed by user (QS2)";
+            }
+        }
+        if (input.service_json.publish) {
+            const cs17 = checklist.items.find(i => i.id === "C-S-17");
+            if (cs17 && !cs17.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 publish (QS1)",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: SERVICE_CONFIRM_VERSION,
+                        final_status: "blocked_user",
+                        layers_passed: layersPassed,
+                        layers_failed: layersFailed,
+                    },
+                };
+            }
+        }
+        if (input.service_json.builder) {
+            const cs18 = checklist.items.find(i => i.id === "C-S-18");
+            if (cs18 && !cs18.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 ownership transfer (QS2)",
+                    decision_record: {
+                        timestamp: new Date().toISOString(),
+                        gate_version: SERVICE_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: SERVICE_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: SERVICE_CONFIRM_VERSION,
+            final_status: "approved",
+            layers_passed: layersPassed,
+            layers_failed: layersFailed,
+        },
+    };
+}
+function generateConfirmationText(input, checklist, assessment) {
+    const lines = [];
+    const data = input.service_json;
+    lines.push("═══ Service Confirmation ═══");
+    lines.push("");
+    if (data.object) {
+        lines.push(`Service: ${data.object}`);
+    }
+    else {
+        lines.push("Service: NEW (to be created)");
+    }
+    if (data.description)
+        lines.push(`Description: ${data.description}`);
+    if (input.current_bPublished !== undefined)
+        lines.push(`Currently published: ${input.current_bPublished}`);
+    if (input.current_bPaused !== undefined)
+        lines.push(`Currently paused: ${input.current_bPaused}`);
+    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.slice(0, 10)) {
+            lines.push(`  [${r.level}] ${r.id}: ${r.title}`);
+        }
+        if (assessment.risks.length > 10) {
+            lines.push(`  ... and ${assessment.risks.length - 10} more`);
+        }
+        lines.push("");
+    }
+    lines.push("─ Operations ──────────────────");
+    if (data.sales)
+        lines.push(`- Sales ${data.sales.op}`);
+    if (data.machine !== undefined)
+        lines.push(`- Machine: ${data.machine ?? "(unbind)"} ${input.current_bPublished ? "[BLOCKED post-publish]" : ""}`);
+    if (data.buy_guard !== undefined)
+        lines.push(`- Buy Guard: ${data.buy_guard ?? "(clear)"}`);
+    if (data.arbitrations)
+        lines.push(`- Arbitrations ${data.arbitrations.op}`);
+    if (data.repositories)
+        lines.push(`- Repositories ${data.repositories.op}`);
+    if (data.rewards)
+        lines.push(`- Rewards ${data.rewards.op}`);
+    if (data.order_allocators !== undefined)
+        lines.push(`- Order Allocators: ${data.order_allocators ? "(set)" : "(clear)"}`);
+    if (data.discount)
+        lines.push(`- Discount: ${data.discount.name} (${data.discount.count} coupons)`);
+    if (data.pause !== undefined)
+        lines.push(`- Pause: ${data.pause}`);
+    if (data.publish)
+        lines.push(`- ⚠️ PUBLISH (IRREVERSIBLE)`);
+    if (data.compensation_fund_add)
+        lines.push(`- Compensation fund deposit: ${data.compensation_fund_add.balance}`);
+    if (data.compensation_fund_withdraw)
+        lines.push(`- ⚠️ Compensation fund withdraw (requires paused + lock expired)`);
+    if (data.setting_locked_time_add !== undefined)
+        lines.push(`- Setting lock +${data.setting_locked_time_add}ms`);
+    if (data.order_new)
+        lines.push(`- ⚠️ ORDER NEW (8-stage flow, stock deducted at quote)`);
+    if (data.builder)
+        lines.push(`- ⚠️ TRANSFER to: ${data.builder} (IRREVERSIBLE)`);
+    if (data.um !== undefined)
+        lines.push(`- UM: ${data.um ?? "(revoke)"}`);
+    lines.push("");
+    return lines.join("\n");
+}
+export function progressiveServiceCheck(input) {
+    const checklist = runStaticChecklist(input);
+    if (!checklist.all_passed) {
+        return {
+            stage: "checklist",
+            status: "fail",
+            message: `Checklist failed: ${checklist.items.filter(i => !i.passed && i.id !== "C-S-17" && i.id !== "C-S-18").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",
+        };
+    }
+    if (assessment.needs_human_review) {
+        return {
+            stage: "confirmation",
+            status: "pending",
+            message: "Human review required for HIGH risks",
+            next_action: "Confirm risk acceptance via user questions",
+        };
+    }
+    return {
+        stage: "complete",
+        status: "pass",
+        message: "All checks passed",
+    };
+}