@wowok/agent-mcp 2.6.0 → 2.6.1

package/dist/knowledge/guard-templates.js

@@ -740,6 +740,284 @@ export const GUARD_TEMPLATES = [
         example_use_case: "Food delivery: if delivery delayed > 30min at node 'delayed' (history count=5), restaurant Treasury auto-compensates $5 to customer with PaymentInfo(for_object=order, for_guard=this, index=5, remark='delayed'). Customer submits Payment via Passport, guard verifies index matches current history count AND remark matches current node name.",
         verifier_constraint_level: "level3_scene_combined",
     },
+    {
+        id: "tpl_forward_content_subscription_deliver",
+        scene_id: "machine_forward_guard",
+        name: "Content subscription delivery verification (Substack-style)",
+        description: "Forward guard for content subscription delivery flow. Verifies that (1) the order is at the expected pre-delivery node " +
+            "(e.g. 'Ordered'), AND (2) the Signer holds the author's permission index on the bound Permission object. " +
+            "Prevents unauthorized parties from publishing content on behalf of the author. " +
+            "Designed for Substack-style content subscription: Paid → ContentPublished → Completed (success path), " +
+            "with Cancelled and Disputed branches using separate guards (tpl_forward_content_subscription_cancel, " +
+            "tpl_forward_content_subscription_refund).",
+        recommended_patterns: ["P06", "P09"],
+        parameters: [
+            {
+                name: "expected_pre_delivery_node",
+                type: "string",
+                description: "Expected current node name BEFORE delivery (e.g. 'Ordered')",
+                required: true,
+                default: "Ordered",
+                constraint: "Must exactly match the name defined in Machine nodes (case-sensitive). This is the node from which the 'Deliver' forward advances.",
+            },
+            {
+                name: "permission_object",
+                type: "address",
+                description: "Permission object address bound to the Machine (author role lives here)",
+                required: true,
+                constraint: "Must be the same Permission object bound to the Machine. Use name (not address) if Permission is not yet created.",
+            },
+            {
+                name: "author_permission_index",
+                type: "number",
+                description: "Permission index reserved for the author role (who can publish content)",
+                required: true,
+                default: "1000",
+                constraint: "Must match the index configured in the Permission object. Substack convention: 1000=author, 1500=arbitrator, reader uses namedOperator='' (no specific operator).",
+            },
+        ],
+        example_table: [
+            {
+                identifier: 0,
+                b_submission: true,
+                value_type: "Address",
+                object_type: "Order",
+                name: "Order object address (submitted by verifier at runtime)",
+                binding_constraint: "Must be an Order belonging to the bound Service; progress.current must match expected_pre_delivery_node",
+            },
+            {
+                identifier: 1,
+                b_submission: false,
+                value_type: "String",
+                value: "${expected_pre_delivery_node}",
+                name: "Expected pre-delivery node name (e.g. 'Ordered')",
+            },
+            {
+                identifier: 2,
+                b_submission: false,
+                value_type: "Address",
+                value: "${permission_object}",
+                name: "Permission object address (bound to Machine, holds author role)",
+            },
+            {
+                identifier: 3,
+                b_submission: false,
+                value_type: "U64",
+                value: "${author_permission_index}",
+                name: "Author permission index (e.g. 1000)",
+            },
+        ],
+        example_root: {
+            type: "logic_and",
+            nodes: [
+                {
+                    type: "logic_string_nocase_equal",
+                    nodes: [
+                        { type: "query", query: "progress.current", object: { identifier: 0, convert_witness: "OrderProgress" }, parameters: [] },
+                        { type: "identifier", identifier: 1 },
+                    ],
+                },
+                {
+                    type: "logic_equal",
+                    nodes: [
+                        { type: "context", context: "Signer" },
+                        {
+                            type: "query",
+                            query: "permission.permitted",
+                            object: { identifier: 2 },
+                            parameters: [{ type: "context", context: "Signer" }, { type: "identifier", identifier: 3 }],
+                        },
+                    ],
+                },
+            ],
+        },
+        applicable_industries: ["subscription", "content", "newsletter", "media"],
+        relevant_risks: ["R-C2-01", "R-C2-03", "R-X1-08"],
+        creation_notes: [
+            "VERIFIED QUERY NAMES: progress.current (id 1253, String) — current node name; permission.permitted (Permission object query, returns Address of permitted operator for the given index)",
+            "SUBSTACK DEPLOYMENT: this guard was used in Substack v2 Service. Original v1 Service was published without arbitrations — had to be recreated as v2 with arbitrations bound BEFORE publish (F-S-21).",
+            "AUTHOR ROLE: permission index 1000 = author (publish + cancel). namedOperator='' for reader role (open — any subscriber). Arbitrator uses index 1500.",
+            "FORWARD DESIGN: 'Deliver' forward advances from 'Ordered' → 'ContentPublished'. Threshold=1, weight=1, permissionIndex=1000 (author only).",
+            "GUARD-FIRST-WINS: when 'Ordered' has competing forwards (Deliver|Cancel|Dispute), each with its own guard, the first guard to verify wins. Subscribers cannot double-claim by triggering multiple forwards.",
+            "IMMUTABILITY: Forward.guard cannot be modified after Machine publish. Verify all 3 guards (deliver/cancel/refund) are correctly bound BEFORE publishing the Machine.",
+            "CIRCULAR REF: if Permission is not yet created, use its name (not address) in value field — Guard resolves names at evaluation time, not at creation time.",
+        ],
+        example_use_case: "Substack newsletter: subscriber pays $5/month. Author publishes content → 'Deliver' forward advances Ordered→ContentPublished. " +
+            "This guard verifies (1) order is at 'Ordered' node (not already delivered), AND (2) Signer holds permission index 1000 on author's Permission object. " +
+            "Prevents a malicious party from publishing fake content. Subscriber cannot trigger 'Deliver' (lacks permission).",
+        verifier_constraint_level: "level2_identity_set",
+    },
+    {
+        id: "tpl_forward_content_subscription_cancel",
+        scene_id: "machine_forward_guard",
+        name: "Content subscription cancel verification (Substack-style)",
+        description: "Forward guard for content subscription cancel flow. Verifies that (1) the order is at the expected pre-cancel node " +
+            "(e.g. 'Ordered'), AND (2) the Signer is the order owner (subscriber). Allows subscriber to cancel within grace period " +
+            "for full refund. Designed for Substack-style: Paid → Cancelled (terminal-cancel), with refund via Allocation template.",
+        recommended_patterns: ["P06", "P09"],
+        parameters: [
+            {
+                name: "expected_pre_cancel_node",
+                type: "string",
+                description: "Expected current node name BEFORE cancel (e.g. 'Ordered')",
+                required: true,
+                default: "Ordered",
+                constraint: "Must exactly match the name defined in Machine nodes (case-sensitive).",
+            },
+        ],
+        example_table: [
+            {
+                identifier: 0,
+                b_submission: true,
+                value_type: "Address",
+                object_type: "Order",
+                name: "Order object address (submitted by verifier at runtime)",
+            },
+            {
+                identifier: 1,
+                b_submission: false,
+                value_type: "String",
+                value: "${expected_pre_cancel_node}",
+                name: "Expected pre-cancel node name (e.g. 'Ordered')",
+            },
+        ],
+        example_root: {
+            type: "logic_and",
+            nodes: [
+                {
+                    type: "logic_string_nocase_equal",
+                    nodes: [
+                        { type: "query", query: "progress.current", object: { identifier: 0, convert_witness: "OrderProgress" }, parameters: [] },
+                        { type: "identifier", identifier: 1 },
+                    ],
+                },
+                {
+                    type: "logic_equal",
+                    nodes: [
+                        { type: "context", context: "Signer" },
+                        { type: "query", query: "order.owner", object: { identifier: 0 }, parameters: [] },
+                    ],
+                },
+            ],
+        },
+        applicable_industries: ["subscription", "content", "newsletter", "media"],
+        relevant_risks: ["R-C2-01", "R-C2-03"],
+        creation_notes: [
+            "VERIFIED QUERY NAMES: progress.current (id 1253, String); order.owner (id 1202, Address) — order holder (subscriber).",
+            "SUBSCRIBER-ONLY: only the order owner can cancel — prevents third-party griefing. Author cannot cancel on behalf of subscriber.",
+            "GRACE PERIOD: this guard does NOT enforce a time window. If a grace period is needed (e.g. cancel within 24h of payment), add a third condition: context(Clock) <= order.time + grace_period.",
+            "REFUND ALLOCATION: pair this guard with an Allocation template that refunds 100% to the subscriber (order.owner). Trigger node = 'Cancelled'.",
+            "GUARD-FIRST-WINS: when 'Ordered' has competing forwards (Deliver|Cancel|Dispute), each with its own guard, the first guard to verify wins.",
+        ],
+        example_use_case: "Substack newsletter: subscriber pays $5, then changes mind before content is published. 'Cancel' forward advances Ordered→Cancelled. " +
+            "This guard verifies (1) order is at 'Ordered' (not yet delivered), AND (2) Signer is the order owner. " +
+            "Author cannot cancel on behalf of subscriber. Refund triggers automatically via Allocation on 'Cancelled' node.",
+        verifier_constraint_level: "level2_identity_set",
+    },
+    {
+        id: "tpl_forward_content_subscription_refund",
+        scene_id: "machine_forward_guard",
+        name: "Content subscription refund verification (Substack-style, arbitration-triggered)",
+        description: "Forward guard for content subscription dispute/refund flow. Verifies that (1) the order is at the expected pre-dispute node " +
+            "(e.g. 'Disputed'), AND (2) the Signer holds the arbitrator's permission index on the bound Permission object. " +
+            "Only the arbitrator can advance Disputed→Refunded, ensuring dispute resolution is impartial. " +
+            "Designed for Substack-style: Paid → Disputed → Refunded (terminal-dispute).",
+        recommended_patterns: ["P06", "P09"],
+        parameters: [
+            {
+                name: "expected_pre_refund_node",
+                type: "string",
+                description: "Expected current node name BEFORE refund (e.g. 'Disputed')",
+                required: true,
+                default: "Disputed",
+                constraint: "Must exactly match the name defined in Machine nodes (case-sensitive).",
+            },
+            {
+                name: "permission_object",
+                type: "address",
+                description: "Permission object address bound to the Machine (arbitrator role lives here)",
+                required: true,
+                constraint: "Must be the same Permission object bound to the Machine. Use name (not address) if Permission is not yet created.",
+            },
+            {
+                name: "arbitrator_permission_index",
+                type: "number",
+                description: "Permission index reserved for the arbitrator role (who can resolve disputes)",
+                required: true,
+                default: "1500",
+                constraint: "Must match the index configured in the Permission object. Substack convention: 1000=author, 1500=arbitrator.",
+            },
+        ],
+        example_table: [
+            {
+                identifier: 0,
+                b_submission: true,
+                value_type: "Address",
+                object_type: "Order",
+                name: "Order object address (submitted by verifier at runtime)",
+            },
+            {
+                identifier: 1,
+                b_submission: false,
+                value_type: "String",
+                value: "${expected_pre_refund_node}",
+                name: "Expected pre-refund node name (e.g. 'Disputed')",
+            },
+            {
+                identifier: 2,
+                b_submission: false,
+                value_type: "Address",
+                value: "${permission_object}",
+                name: "Permission object address (bound to Machine, holds arbitrator role)",
+            },
+            {
+                identifier: 3,
+                b_submission: false,
+                value_type: "U64",
+                value: "${arbitrator_permission_index}",
+                name: "Arbitrator permission index (e.g. 1500)",
+            },
+        ],
+        example_root: {
+            type: "logic_and",
+            nodes: [
+                {
+                    type: "logic_string_nocase_equal",
+                    nodes: [
+                        { type: "query", query: "progress.current", object: { identifier: 0, convert_witness: "OrderProgress" }, parameters: [] },
+                        { type: "identifier", identifier: 1 },
+                    ],
+                },
+                {
+                    type: "logic_equal",
+                    nodes: [
+                        { type: "context", context: "Signer" },
+                        {
+                            type: "query",
+                            query: "permission.permitted",
+                            object: { identifier: 2 },
+                            parameters: [{ type: "context", context: "Signer" }, { type: "identifier", identifier: 3 }],
+                        },
+                    ],
+                },
+            ],
+        },
+        applicable_industries: ["subscription", "content", "newsletter", "media"],
+        relevant_risks: ["R-C2-01", "R-C2-03", "R-X1-08"],
+        creation_notes: [
+            "VERIFIED QUERY NAMES: progress.current (id 1253, String); permission.permitted (Permission object query, returns Address of permitted operator for the given index).",
+            "ARBITRATOR-ONLY: only the arbitrator (permission index 1500) can advance Disputed→Refunded. Neither author nor subscriber can self-resolve.",
+            "ARBITRATIONS BINDING: Service MUST have arbitrations bound BEFORE publish (F-S-21 — post-publish immutable). ConfirmGate C-S-19 + QS11 will warn if publish is attempted without arbitrations.",
+            "DISPUTE ENTRY: 'Dispute' forward (Ordered→Disputed) is triggered by subscriber (order.owner). After Disputed, only arbitrator can resolve.",
+            "REFUND ALLOCATION: pair this guard with an Allocation template that refunds 100% to the subscriber (order.owner). Trigger node = 'Refunded'.",
+            "GUARD-FIRST-WINS: when 'Disputed' has competing forwards (Resolve-Refund|Resolve-Reject), each with its own guard. First guard to verify wins.",
+        ],
+        example_use_case: "Substack newsletter: subscriber disputes content quality. Subscriber triggers 'Dispute' forward (Ordered→Disputed). " +
+            "Arbitrator reviews evidence and triggers 'Resolve-Refund' forward (Disputed→Refunded). " +
+            "This guard verifies (1) order is at 'Disputed' (dispute properly opened), AND (2) Signer holds arbitrator permission index 1500. " +
+            "Author cannot self-resolve. Subscriber cannot self-refund.",
+        verifier_constraint_level: "level2_identity_set",
+    },
 ];
 export function getTemplatesByScene(sceneId) {
     return GUARD_TEMPLATES.filter((t) => t.scene_id === sceneId);

package/dist/knowledge/machine-templates.js

@@ -1316,14 +1316,33 @@ export const MACHINE_TEMPLATES = [
             "Repository records subscription status for cross-Machine verification",
             "Renewal Allocation triggers on Renewed node (not Active — avoids double-charge)",
             "Note: consensus_repositories is declarative-only (NOT auto-passed to Progress); use repository_ref parameter for actual Repository object — see 06 §14.4",
+            "VARIANT — Content subscription (Substack-style): replace time-lock Renew/Expire with content-delivery flow:",
+            "  6-node variant: Paid (entry) → ContentPublished → Completed (terminal-success)",
+            "                  Paid → Cancelled (terminal-cancel) | Paid → Disputed → Refunded (terminal-dispute)",
+            "  Permission: author=index 1000 (publish + cancel), arbitrator=index 1500 (resolve dispute), reader=namedOperator='' (open role, no specific operator)",
+            "  Guards: deliver_guard (verify author permission + content hash), cancel_guard (verify subscriber request), refund_guard (verify arbitration outcome)",
+            "  Allocators: deliver=100% to author, cancel=100% refund to subscriber, dispute=100% refund to subscriber (Guard-first-wins pattern)",
+            "  First-Forward-wins: when Paid has competing forwards (Deliver|Cancel|Dispute), the first triggered forward wins; subscribers cannot double-claim",
+            "CRITICAL — v1→v2 lesson: arbitrations MUST be added BEFORE Service.publish (post-publish, arbitrations become immutable and cannot be added — service.move F-S-21)",
+            "  If you accidentally published without arbitrations, you MUST create a new Service v2 with arbitrations bound before publishing (the v1 Service must be paused/abandoned)",
+            "  ConfirmGate (C-S-19, QS11) will warn before publish without arbitrations — do not bypass this warning unless explicitly intending no-arbitration operation",
+            "Build order (content variant): Permission → Machine (unpublished, with initial forward) → 3 Guards → 3 Allocators (template on Service) → Service (unpublished, bind machine+buy_guard+order_allocators+arbitrations) → Publish Service → Test order (3 paths: normal/cancel/dispute)",
         ],
         example_use_case: "Monthly SaaS subscription: $10/month. Customer can renew anytime after day 25. " +
-            "Auto-expire on day 35 if not renewed. Cancel anytime.",
+            "Auto-expire on day 35 if not renewed. Cancel anytime.\n\n" +
+            "VARIANT — Content subscription (Substack-style): $5/month newsletter. Author publishes content → " +
+            "subscriber reads. Subscriber can cancel anytime for full refund. Disputes resolved by arbitrator " +
+            "(100% refund to subscriber if dispute upheld). 6-node Machine, 3 Guards, 3 Allocators. " +
+            "Tested on testnet with 3 order paths: normal delivery, cancel, dispute.",
         publish_checklist: [
             "Time-lock Guards tested on testnet (both TimeUnlock + AutoExpire)",
             "Competing Pair semantics verified (Renew vs Expire vs Cancel)",
             "Repository write tested (subscription status queryable)",
             "Renewal loop tested: Paid -> Active -> RenewEligible -> Renewed -> Active",
+            "Content variant: initial node (prev_node='') MUST have at least one forward (FIX-002) — empty forwards=[] causes Progress to be permanently stuck",
+            "Content variant: arbitrations added BEFORE publish (cannot add post-publish per F-S-21)",
+            "Content variant: 3 order paths tested on testnet — normal delivery, cancel-within-grace, dispute-resolution",
+            "Content variant: machineNode2file export as backup (covers all 6 nodes)",
         ],
     },
 ];

package/dist/knowledge/service-confirm.d.ts

@@ -35,13 +35,18 @@ export interface ServiceConfirmationResponse {
     question_id: string;
     response: "yes" | "no" | "skip";
 }
+export type ServiceEnvironmentCheckLevel = "block" | "warning" | "info";
+export interface ServiceEnvironmentCheck {
+    name: string;
+    passed: boolean;
+    message: string;
+    level?: ServiceEnvironmentCheckLevel;
+}
 export interface ServiceEnvironmentResult {
     passed: boolean;
-    checks: {
-        name: string;
-        passed: boolean;
-        message: string;
-    }[];
+    checks: ServiceEnvironmentCheck[];
+    warnings_count: number;
+    infos_count: number;
 }
 export interface ServiceDecisionRecord {
     timestamp: string;
@@ -138,6 +143,10 @@ export interface ServiceConfirmGateInput {
     current_order_allocators_set?: boolean;
     skip_user_confirmation?: boolean;
     skip_environment_check?: boolean;
+    current_machine_node_count?: number;
+    current_machine_initial_forward_ok?: boolean;
+    current_machine_bPublished?: boolean;
+    current_arbitrators_authorized?: boolean;
 }
 export declare const SERVICE_PUBLISH_CHECKLIST: ServiceChecklistItem[];
 export declare const SERVICE_CONFIRMATION_QUESTIONS: ServiceConfirmationQuestion[];

package/dist/knowledge/service-confirm.js

@@ -19,6 +19,7 @@ export const SERVICE_PUBLISH_CHECKLIST = [
     { 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: "" },
+    { id: "C-S-19", description: "Publish: arbitrations strongly recommended (cannot add post-publish, F-S-21)", passed: false, message: "" },
 ];
 function runStaticChecklist(input) {
     const items = SERVICE_PUBLISH_CHECKLIST.map(c => ({ ...c }));
@@ -227,7 +228,24 @@ function runStaticChecklist(input) {
     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);
+    if (data.publish) {
+        const currentArbCount = input.current_arbitrations_count ?? 0;
+        const arbFromInput = data.arbitrations && "objects" in data.arbitrations ? data.arbitrations.objects.length : 0;
+        const arbCleared = data.arbitrations && data.arbitrations.op === "clear";
+        const totalArb = arbCleared ? 0 : currentArbCount + arbFromInput;
+        const cs19 = items.find(i => i.id === "C-S-19");
+        if (totalArb === 0) {
+            cs19.passed = false;
+            cs19.message = "Pending user confirmation in Layer 3 (QS11) — arbitrations cannot be added post-publish";
+        }
+        else {
+            cs19.passed = true;
+        }
+    }
+    else {
+        items.find(i => i.id === "C-S-19").passed = true;
+    }
+    const allPassed = items.filter(i => i.id !== "C-S-17" && i.id !== "C-S-18" && i.id !== "C-S-19").every(i => i.passed);
     return { all_passed: allPassed, items };
 }
 function adaptRiskAssessment(input) {
@@ -327,6 +345,16 @@ export const SERVICE_CONFIRMATION_QUESTIONS = [
         question: "Have you exported the current Service JSON as a backup before this operation?",
         requires_explicit_yes: false,
     },
+    {
+        id: "QS11",
+        question: "⚠️ Service is about to be published WITHOUT arbitrations.\n\n" +
+            "After publishing, arbitrations CANNOT be added (contract restriction, F-S-21).\n" +
+            "Dispute resolution will NOT be available for this service.\n\n" +
+            "Recommended: Set arbitrations BEFORE publishing:\n" +
+            '  "arbitrations": {"op": "add", "objects": ["your_arbitration_object"]}\n\n' +
+            "Continue with publish anyway?",
+        requires_explicit_yes: true,
+    },
 ];
 function processUserConfirmation(input, assessment) {
     const questions = [...SERVICE_CONFIRMATION_QUESTIONS];
@@ -350,6 +378,18 @@ function processUserConfirmation(input, assessment) {
         irrelevant.push("QS8");
     if (!data.order_new)
         irrelevant.push("QS9");
+    if (!data.publish) {
+        irrelevant.push("QS11");
+    }
+    else {
+        const currentArbCount = input.current_arbitrations_count ?? 0;
+        const arbFromInput = data.arbitrations && "objects" in data.arbitrations ? data.arbitrations.objects.length : 0;
+        const arbCleared = data.arbitrations && data.arbitrations.op === "clear";
+        const totalArb = arbCleared ? 0 : currentArbCount + arbFromInput;
+        if (totalArb > 0) {
+            irrelevant.push("QS11");
+        }
+    }
     const filtered = questions.filter(q => !irrelevant.includes(q.id));
     if (input.skip_user_confirmation) {
         return {
@@ -413,6 +453,40 @@ function verifyEnvironment(input) {
                 message: "Publish blocked: compensation_fund > 0 but no arbitrations (E_ARBITRATION_NOT_SET_WITH_COMPENSATION_FUND)",
             });
         }
+        if (data.machine) {
+            if (input.current_machine_node_count !== undefined && input.current_machine_node_count === 0) {
+                checks.push({
+                    name: "machine_has_nodes",
+                    passed: false,
+                    message: "Publish blocked: bound Machine has 0 nodes — Progress will be permanently stuck",
+                });
+            }
+            if (input.current_machine_initial_forward_ok === false) {
+                checks.push({
+                    name: "machine_initial_forward",
+                    passed: false,
+                    message: "Publish blocked: bound Machine's initial node (prev_node='') has no forward — Progress cannot advance from '' (FIX-002 violated)",
+                });
+            }
+            if (input.current_machine_bPublished === false) {
+                checks.push({
+                    name: "machine_not_published",
+                    passed: true,
+                    level: "warning",
+                    message: "Warning: bound Machine is not yet published. Orders cannot advance until the Machine is published. Publish the Machine after this Service to enable order workflow.",
+                });
+            }
+        }
+        const arbCountForPerm = input.current_arbitrations_count ?? 0;
+        const arbFromInputForPerm = data.arbitrations && "objects" in data.arbitrations ? data.arbitrations.objects.length : 0;
+        if ((arbCountForPerm + arbFromInputForPerm) > 0 && input.current_arbitrators_authorized === false) {
+            checks.push({
+                name: "arbitrators_permission_authorized",
+                passed: true,
+                level: "info",
+                message: "Info: ensure arbitrators have been granted the required permission index in the Permission object. Without authorization, dispute resolution Guards will reject arbitrator signatures (Permission denied).",
+            });
+        }
     }
     if (input.current_bPublished) {
         if (data.machine !== undefined) {
@@ -445,7 +519,9 @@ function verifyEnvironment(input) {
         });
     }
     const allPassed = checks.every(c => c.passed);
-    return { passed: allPassed, checks };
+    const warnings_count = checks.filter(c => c.level === "warning").length;
+    const infos_count = checks.filter(c => c.level === "info").length;
+    return { passed: allPassed, checks, warnings_count, infos_count };
 }
 export const SERVICE_CONFIRM_VERSION = "1.0.0";
 export function runServiceConfirmGate(input) {
@@ -458,7 +534,7 @@ export function runServiceConfirmGate(input) {
             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(", ")}`,
+            block_reason: `Checklist failed: ${checklist.items.filter(i => !i.passed && i.id !== "C-S-17" && i.id !== "C-S-18" && i.id !== "C-S-19").map(i => i.id).join(", ")}`,
             decision_record: {
                 timestamp: new Date().toISOString(),
                 gate_version: SERVICE_CONFIRM_VERSION,
@@ -507,6 +583,15 @@ export function runServiceConfirmGate(input) {
                 cs18.message = cs18.passed ? "" : "Transfer not confirmed by user (QS2)";
             }
         }
+        const cs19 = checklist.items.find(i => i.id === "C-S-19");
+        if (cs19 && !cs19.passed) {
+            const qs11Asked = userConf.questions_asked.some(q => q.id === "QS11");
+            if (qs11Asked) {
+                const qs11 = userConf.responses.find(r => r.question_id === "QS11");
+                cs19.passed = qs11?.response === "yes";
+                cs19.message = cs19.passed ? "" : "User declined publish without arbitrations (QS11)";
+            }
+        }
         if (input.service_json.publish) {
             const cs17 = checklist.items.find(i => i.id === "C-S-17");
             if (cs17 && !cs17.passed) {
@@ -549,23 +634,45 @@ export function runServiceConfirmGate(input) {
                 };
             }
         }
+        if (cs19 && !cs19.passed) {
+            const qs11Asked = userConf.questions_asked.some(q => q.id === "QS11");
+            if (qs11Asked) {
+                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 without arbitrations (QS11) — set arbitrations or explicitly confirm",
+                    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");
+    let envResult;
     if (input.skip_environment_check) {
         layersPassed.push("L4_environment");
     }
     else {
-        const env = verifyEnvironment(input);
-        if (!env.passed) {
+        envResult = verifyEnvironment(input);
+        if (!envResult.passed) {
             layersFailed.push("L4_environment");
             return {
                 status: "blocked_environment",
                 checklist_result: checklist,
                 risk_result: assessment,
                 user_confirmation: userConf,
-                environment_result: env,
+                environment_result: envResult,
                 confirmation_text: generateConfirmationText(input, checklist, assessment),
-                block_reason: `Environment check failed: ${env.checks.filter(c => !c.passed).map(c => c.name).join(", ")}`,
+                block_reason: `Environment check failed: ${envResult.checks.filter(c => !c.passed).map(c => c.name).join(", ")}`,
                 decision_record: {
                     timestamp: new Date().toISOString(),
                     gate_version: SERVICE_CONFIRM_VERSION,
@@ -582,6 +689,7 @@ export function runServiceConfirmGate(input) {
         checklist_result: checklist,
         risk_result: assessment,
         user_confirmation: userConf,
+        environment_result: envResult,
         confirmation_text: generateConfirmationText(input, checklist, assessment),
         decision_record: {
             timestamp: new Date().toISOString(),
@@ -670,7 +778,7 @@ export function progressiveServiceCheck(input) {
         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(", ")}`,
+            message: `Checklist failed: ${checklist.items.filter(i => !i.passed && i.id !== "C-S-17" && i.id !== "C-S-18" && i.id !== "C-S-19").map(i => i.id).join(", ")}`,
             next_action: "Fix failing checklist items",
         };
     }

package/dist/knowledge/tool-constraints.js

@@ -33,9 +33,13 @@ export const TOOL_CONSTRAINTS = [
                         return true;
                     if (!d?.publish)
                         return true;
-                    return Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0;
+                    if (Array.isArray(d?.node?.nodes) && d.node.nodes.length > 0)
+                        return true;
+                    if (typeof d?.node?.json_or_markdown_file === "string" && d.node.json_or_markdown_file.length > 0)
+                        return true;
+                    return false;
                 },
-                message: () => "Publishing a Machine without nodes — a workflow template requires at least one node. Consider adding nodes before publish, or publish later after adding nodes.",
+                message: () => "Publishing a Machine without nodes — a workflow template requires at least one node. Provide nodes via inline `node.nodes` array OR `node.json_or_markdown_file` path (file contains JSON or Markdown node definitions). Consider adding nodes before publish, or publish later after adding nodes.",
             },
         ],
     },

package/dist/project/deployment-bridge.d.ts

@@ -1,5 +1,5 @@
 import type { DeploymentDocValidationResult } from "./deployment-doc.js";
-export declare function generateDeploymentDocFromProject(projectId: string, network: "testnet" | "mainnet"): Promise<{
+export declare function generateDeploymentDocFromProject(projectId: string, network: "testnet" | "mainnet", detailLevel?: "summary" | "detailed" | "full"): Promise<{
     markdown: string;
     validation: DeploymentDocValidationResult;
 }>;