@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/progress-ledger.js

@@ -0,0 +1,327 @@
+import { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT, } from "@wowok/wowok";
+export { MAX_NAMED_OPERATOR_COUNT, MAX_NAMED_OPERATOR_ADDRESS_COUNT, MAX_CONTEXT_REPOSITORY_COUNT, };
+export const PROGRESS_NEW = {
+    index: 220,
+    name: "PROGRESS_NEW",
+    description: "Create new Progress (asserted by progress::new / new_with_passport)",
+    governed_operations: ["progress::new", "progress::new_with_passport"],
+    sdk_exposed: false,
+};
+export const PROGRESS_NAMED_OPERATOR = {
+    index: 221,
+    name: "PROGRESS_NAMED_OPERATOR",
+    description: "Manage named operators (add/set/remove) for the namedOperator namespace",
+    governed_operations: [
+        "progress::namedOperator_add",
+        "progress::namedOperator_set",
+        "progress::namedOperator_remove",
+        "progress::namedOperator_add_with_passport",
+        "progress::namedOperator_set_with_passport",
+        "progress::namedOperator_remove_with_passport",
+    ],
+    sdk_exposed: true,
+};
+export const PROGRESS_TASK = {
+    index: 222,
+    name: "PROGRESS_TASK",
+    description: "Submit task (one-time, immutable once set — E_TASK_ALREADY_SET)",
+    governed_operations: ["progress::task_set", "progress::task_set_with_passport"],
+    sdk_exposed: true,
+};
+export const PROGRESS_CONTEXT_REPOSITORY = {
+    index: 223,
+    name: "PROGRESS_CONTEXT_REPOSITORY",
+    description: "Bind/unbind context Repository (≤ MAX_CONTEXT_REPOSITORY_COUNT=30)",
+    governed_operations: [
+        "progress::context_repository_add",
+        "progress::context_repository_remove",
+        "progress::context_repository_clear",
+        "progress::context_repository_add_with_passport",
+        "progress::context_repository_remove_with_passport",
+        "progress::context_repository_clear_with_passport",
+    ],
+    sdk_exposed: true,
+};
+export const PROGRESS_UNHOLD = {
+    index: 224,
+    name: "PROGRESS_UNHOLD",
+    description: "Force unhold (adminUnhold) — bypasses holder check, releases blocked forward",
+    governed_operations: ["progress::unhold", "progress::unhold_with_passport"],
+    sdk_exposed: true,
+};
+export const PROGRESS_OWNER_RECEIVE = {
+    index: 225,
+    name: "PROGRESS_OWNER_RECEIVE",
+    description: "Owner receives objects/coins (unwrap Receiving<K> → owner)",
+    governed_operations: [
+        "progress::owner_receive",
+        "progress::owner_receive_object",
+        "progress::owner_receive_with_passport",
+        "progress::owner_receive_object_with_passport",
+    ],
+    sdk_exposed: false,
+};
+export const PROGRESS_PERMISSIONS = [
+    PROGRESS_NEW,
+    PROGRESS_NAMED_OPERATOR,
+    PROGRESS_TASK,
+    PROGRESS_CONTEXT_REPOSITORY,
+    PROGRESS_UNHOLD,
+    PROGRESS_OWNER_RECEIVE,
+];
+export const PROGRESS_SCENES = [
+    {
+        id: "progress_task_submit",
+        name: "Task submission & binding workflow",
+        industry: ["universal", "ecommerce", "logistics", "education"],
+        scenario: "Submit a task (Order/Reward/etc.) to Progress via task_set. " +
+            "Task is one-time, immutable — once set, E_TASK_ALREADY_SET blocks any re-assignment. " +
+            "Binds Progress 1:1 to the task object for the rest of its lifecycle.",
+        phases: ["task_binding", "forward_advance"],
+        requires_published_machine: true,
+        requires_order_bound: true,
+        named_operator_roles: [],
+        builtin_indexes_consumed: [PROGRESS_TASK],
+        typical_context_repository_count: 0,
+        uses_hold_mechanism: false,
+        uses_admin_unhold: false,
+        common_patterns: [
+            "task_set is one-time: verify task address before submission (E_TASK_ALREADY_SET blocks reset)",
+            "task is usually an Order created by service::buy → Progress.task = Order address",
+            "Without task, Forward advancement falls back to non-order next()/hold() paths",
+        ],
+        recommended_templates: ["T-PR-01"],
+    },
+    {
+        id: "progress_named_operator",
+        name: "Named operator namespace management",
+        industry: ["universal", "logistics", "arbitration", "freelance"],
+        scenario: "Manage named_operator namespace for a Progress. Each named operator is a (name → address list) " +
+            "binding used by Machine.forward.namedOperator to gate next()/hold() advancement. " +
+            "Up to 60 named operators per Progress, up to 80 addresses per operator.",
+        phases: ["named_operator_mgmt"],
+        requires_published_machine: true,
+        requires_order_bound: false,
+        named_operator_roles: [
+            { role: "seller", typical_count: 1 },
+            { role: "logistics", typical_count: 1 },
+            { role: "reviewer", typical_count: 3 },
+            { role: "arbitrator", typical_count: 5 },
+        ],
+        builtin_indexes_consumed: [PROGRESS_NAMED_OPERATOR],
+        typical_context_repository_count: 0,
+        uses_hold_mechanism: false,
+        uses_admin_unhold: false,
+        common_patterns: [
+            "namedOperator name='': special case — means OrderHolder (order.owner/agent), NOT a real named operator",
+            "add/set/remove are idempotent on duplicate addresses (vector::contains check before push)",
+            "Use 'set' to REPLACE an operator's address list; use 'add' to extend; 'remove' to subtract",
+            "Names must satisfy common::NAME (isValidName) — non-empty, length-bounded",
+        ],
+        recommended_templates: ["T-PR-01", "T-PR-02"],
+    },
+    {
+        id: "progress_unhold",
+        name: "Hold release (unhold / adminUnhold) workflow",
+        industry: ["content", "rental", "arbitration", "subscription"],
+        scenario: "Release a forward that was previously held. Two paths: " +
+            "(a) unhold by original holder (named_operator match); " +
+            "(b) adminUnhold (224) by permission-table holder — bypasses holder check. " +
+            "adminUnhold is the deadlock-resolution escape hatch when a holder is unresponsive.",
+        phases: ["hold_state", "unhold_state"],
+        requires_published_machine: true,
+        requires_order_bound: true,
+        named_operator_roles: [
+            { role: "holder", typical_count: 1 },
+            { role: "admin", typical_count: 1 },
+        ],
+        builtin_indexes_consumed: [PROGRESS_UNHOLD],
+        typical_context_repository_count: 0,
+        uses_hold_mechanism: true,
+        uses_admin_unhold: true,
+        common_patterns: [
+            "unhold checks sender_has_permission_idcheck(224): if yes, force release; if no, require holder match",
+            "adminUnhold has wider blast radius — only grant 224 to trusted recovery operators",
+            "If forward already accomplished, E_FORWARD_ALREADY_ACCOMPLISHED blocks re-hold",
+            "Repeated hold/unhold cycles indicate a stuck workflow — surface to order-monitor",
+        ],
+        recommended_templates: ["T-PR-05"],
+    },
+    {
+        id: "progress_context_repository",
+        name: "Context Repository binding workflow",
+        industry: ["education", "content", "rental", "cross_chain"],
+        scenario: "Bind/unbind Repository objects as Progress context_repositories. " +
+            "Used to provide query-time context (learning progress, inspection records, bridge state). " +
+            "Up to MAX_CONTEXT_REPOSITORY_COUNT=30 repositories per Progress.",
+        phases: ["context_binding"],
+        requires_published_machine: true,
+        requires_order_bound: false,
+        named_operator_roles: [],
+        builtin_indexes_consumed: [PROGRESS_CONTEXT_REPOSITORY],
+        typical_context_repository_count: 3,
+        uses_hold_mechanism: false,
+        uses_admin_unhold: false,
+        common_patterns: [
+            "context_repository_add registers affiliation via Registrar (enables cross-object queries)",
+            "context_repository_remove disaffiliates — Repository may be garbage-collected if no other refs",
+            "context_repository_clear empties the entire list in one transaction",
+            "add is idempotent: if Repository already in list, no-op (vector::contains check)",
+            "Bind before forward advance so on-chain guards can read context data",
+        ],
+        recommended_templates: ["T-PR-03"],
+    },
+    {
+        id: "progress_owner_receive",
+        name: "Owner receive (unwrap) workflow",
+        industry: ["finance", "treasury", "rental", "freelance"],
+        scenario: "Owner receives Receiving<K> objects or CoinWrapper<T> coins sent to the Progress object. " +
+            "unwrap → permission::owner_receive_inner forwards to Permission owner. " +
+            "Used at terminal nodes (deposit_refunded, completed, enforced) to disburse funds.",
+        phases: ["owner_receive"],
+        requires_published_machine: true,
+        requires_order_bound: true,
+        named_operator_roles: [],
+        builtin_indexes_consumed: [PROGRESS_OWNER_RECEIVE],
+        typical_context_repository_count: 0,
+        uses_hold_mechanism: false,
+        uses_admin_unhold: false,
+        common_patterns: [
+            "owner_receive unwraps CoinWrapper<T> via Payment.unwrap_with_check (amount validation)",
+            "owner_receive_object receives a generic K:key+store object and forwards to Permission owner",
+            "Triggered at terminal nodes (e.g. 'deposit_refunded' in rental, 'enforced' in arbitration)",
+            "Permission owner ≠ Progress creator: receives flow to whoever owns the bound Machine's Permission",
+        ],
+        recommended_templates: ["T-PR-06"],
+    },
+    {
+        id: "progress_completed",
+        name: "Forward advancement & session completion",
+        industry: ["universal"],
+        scenario: "Advance Progress via next()/order_next() — accumulates weights in session.forwards, " +
+            "and when weights ≥ threshold, moves session into history and updates Progress.current. " +
+            "This is the canonical Forward advancement path for ALL non-hold operations.",
+        phases: ["forward_advance", "completed"],
+        requires_published_machine: true,
+        requires_order_bound: true,
+        named_operator_roles: [
+            { role: "OrderHolder", typical_count: 1 },
+            { role: "next_node_operator", typical_count: 1 },
+        ],
+        builtin_indexes_consumed: [],
+        typical_context_repository_count: 0,
+        uses_hold_mechanism: false,
+        uses_admin_unhold: false,
+        common_patterns: [
+            "Forward guard (Some): requires Passport; uses passport::result_for_guard for verification",
+            "Forward guard (None): requires permissionIndex (Some) or namedOperator match (ASSERT_PERMISSION)",
+            "session.weights += forward.weight; when ≥ threshold, push session into ParentTableVec<History>",
+            "Progress.current = next_node only after session completes (atomic update)",
+            "E_NOT_THE_HOLDER: if forward was held by another address, next() aborts",
+            "E_FORWARD_ALREADY_ACCOMPLISHED: re-hold on completed forward is blocked",
+        ],
+        recommended_templates: ["T-PR-04"],
+    },
+];
+export const PROGRESS_LEDGER_VERSION = "1.0.0";
+export function getScenesByPhase(phase) {
+    return PROGRESS_SCENES.filter(s => s.phases.includes(phase));
+}
+export function findSceneById(id) {
+    return PROGRESS_SCENES.find(s => s.id === id);
+}
+export function getScenesByIndustry(industry) {
+    return PROGRESS_SCENES.filter(s => s.industry.includes(industry) || s.industry.includes("universal"));
+}
+export function getBuiltinPermissionByIndex(index) {
+    return PROGRESS_PERMISSIONS.find(p => p.index === index);
+}
+export function isProgressBuiltinPermission(index) {
+    return getBuiltinPermissionByIndex(index) !== undefined;
+}
+export function inferSceneFromIntent(intent) {
+    const lower = intent.toLowerCase();
+    const keywordMap = [
+        ["adminunhold", "progress_unhold"],
+        ["admin unhold", "progress_unhold"],
+        ["force unhold", "progress_unhold"],
+        ["unhold", "progress_unhold"],
+        ["release hold", "progress_unhold"],
+        ["owner_receive", "progress_owner_receive"],
+        ["owner receive", "progress_owner_receive"],
+        ["unwrap", "progress_owner_receive"],
+        ["context_repository", "progress_context_repository"],
+        ["context repository", "progress_context_repository"],
+        ["repository binding", "progress_context_repository"],
+        ["named_operator", "progress_named_operator"],
+        ["named operator", "progress_named_operator"],
+        ["namedoperator", "progress_named_operator"],
+        ["task_set", "progress_task_submit"],
+        ["task set", "progress_task_submit"],
+        ["submit task", "progress_task_submit"],
+        ["next", "progress_completed"],
+        ["order_next", "progress_completed"],
+        ["advance", "progress_completed"],
+        ["complete", "progress_completed"],
+    ];
+    for (const [kw, sceneId] of keywordMap) {
+        if (lower.includes(kw)) {
+            const scene = findSceneById(sceneId);
+            if (scene)
+                return scene;
+        }
+    }
+    return undefined;
+}
+export function getAllBuiltinPermissions() {
+    return [...PROGRESS_PERMISSIONS];
+}
+export function getProgressScenesCount() {
+    return PROGRESS_SCENES.length;
+}
+export function validateNamedOperatorAddressList(addresses) {
+    const violations = [];
+    if (addresses.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+        violations.push(`Named operator address count ${addresses.length} exceeds MAX_NAMED_OPERATOR_ADDRESS_COUNT ${MAX_NAMED_OPERATOR_ADDRESS_COUNT}`);
+    }
+    const seen = new Set();
+    for (const a of addresses) {
+        if (seen.has(a)) {
+            violations.push(`Duplicate address in list: ${a} (Move will dedupe silently)`);
+            break;
+        }
+        seen.add(a);
+    }
+    return { ok: violations.length === 0, violations };
+}
+export function validateNamedOperatorCount(currentNamedOperatorCount) {
+    if (currentNamedOperatorCount >= MAX_NAMED_OPERATOR_COUNT) {
+        return {
+            ok: false,
+            violation: `Named operator count ${currentNamedOperatorCount} would exceed MAX_NAMED_OPERATOR_COUNT ${MAX_NAMED_OPERATOR_COUNT}`,
+        };
+    }
+    return { ok: true };
+}
+export function validateContextRepositoryCount(currentRepositoryCount, addCount) {
+    const newCount = currentRepositoryCount + addCount;
+    if (newCount > MAX_CONTEXT_REPOSITORY_COUNT) {
+        return {
+            ok: false,
+            violation: `Context repository count ${newCount} would exceed MAX_CONTEXT_REPOSITORY_COUNT ${MAX_CONTEXT_REPOSITORY_COUNT}`,
+        };
+    }
+    return { ok: true };
+}
+export const PROGRESS_CROSS_OBJECT_REFS = [
+    { object: "Machine", phase: "universal", relationship: "Progress.machine (immutable bind, E_MACHINE_NOT_MATCH on every op)" },
+    { object: "Order", phase: "forward_advance", relationship: "Progress.task = Order.address (1:1, set via task_set or service::buy)" },
+    { object: "Order", phase: "forward_advance", relationship: "order_next / order_hold: order.has_op_permission(order, ctx) gates Forward advance" },
+    { object: "Permission", phase: "universal", relationship: "Machine.permission is borrowed for ALL 220-225 assertions" },
+    { object: "Repository", phase: "context_binding", relationship: "context_repositories: vector<address> (≤ 30), affiliated via Registrar" },
+    { object: "Service", phase: "creation", relationship: "service::buy → new_imp (bypasses 220 assertion — package-internal entry)" },
+    { object: "Passport", phase: "forward_advance", relationship: "Forward.guard (Some) requires Passport + passport::result_for_guard" },
+    { object: "Passport", phase: "unhold_state", relationship: "unhold_with_passport: 224 check via passport (fallback when sender_has_permission_idcheck fails)" },
+    { object: "Payment", phase: "owner_receive", relationship: "owner_receive unwraps CoinWrapper<T> via Payment.unwrap_with_check" },
+    { object: "Allocation", phase: "completed", relationship: "Terminal node triggers Allocation alloc (e.g. 'completed', 'enforced', 'deposit_refunded')" },
+];

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

@@ -0,0 +1,82 @@
+import { type ProgressBuiltinPermissionEntry } from "./progress-ledger.js";
+export interface ProgressIntentPuzzle {
+    action: "create" | "operate" | "task_set" | "named_operator" | "repository" | "owner_receive" | "query";
+    target_progress?: string;
+    rule_sentence: string;
+    failure_conditions: string[];
+}
+export interface ProgressWorkflowPuzzle {
+    machine: string;
+    machine_published: boolean;
+    order: string | null;
+    current_node: string;
+    forward_target?: {
+        next_node_name: string;
+        forward: string;
+    };
+    use_order_variant: boolean;
+}
+export interface ProgressNamedOperatorPuzzle {
+    name: string;
+    op: "add" | "set" | "remove";
+    addresses: string[];
+    is_order_holder_namespace: boolean;
+}
+export interface ProgressTaskPuzzle {
+    task_address: string;
+    submitted_data?: {
+        type: "json" | "bcs" | "text";
+        payload: string;
+    };
+    immutability_acknowledged: boolean;
+}
+export interface ProgressPermissionPuzzle {
+    builtin_indexes_used: ProgressBuiltinPermissionEntry[];
+    forward_permission_index: number | null;
+    uses_named_operator_short_circuit: boolean;
+    requires_passport: boolean;
+    uses_order_permission: boolean;
+}
+export interface ProgressConstraintChecklist {
+    F_PR_01_machine_published: boolean;
+    F_PR_02_machine_bound: boolean;
+    F_PR_03_named_operator_count_le_60: boolean;
+    F_PR_04_named_operator_addr_le_80: boolean;
+    F_PR_05_context_repository_le_30: boolean;
+    F_PR_06_task_one_time: boolean;
+    F_PR_07_forward_exists_in_machine: boolean;
+    F_PR_08_holder_match_for_unhold: boolean;
+}
+export type ProgressPuzzleDimension = "A" | "B" | "C" | "D" | "E" | "F";
+export interface ProgressPuzzle {
+    intent?: ProgressIntentPuzzle;
+    workflow?: ProgressWorkflowPuzzle;
+    named_operator?: ProgressNamedOperatorPuzzle;
+    task?: ProgressTaskPuzzle;
+    permission?: ProgressPermissionPuzzle;
+    constraints?: ProgressConstraintChecklist;
+}
+export interface ProgressPuzzleCompleteness {
+    dimensions: ProgressPuzzleDimension[];
+    missing: ProgressPuzzleDimension[];
+    missing_details: {
+        dimension: ProgressPuzzleDimension;
+        reason: string;
+    }[];
+    complete: boolean;
+    next_step: string;
+}
+export declare function initPuzzleFromIntent(intent: Partial<ProgressIntentPuzzle>): ProgressPuzzle;
+export declare function checkPuzzleCompleteness(puzzle: ProgressPuzzle): ProgressPuzzleCompleteness;
+export interface ProgressConstraintViolation {
+    constraint_id: string;
+    severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+    message: string;
+    current_value?: string | number;
+    limit?: string | number;
+}
+export declare function validateConstraints(puzzle: ProgressPuzzle): ProgressConstraintViolation[];
+export declare function generateConfirmationText(puzzle: ProgressPuzzle): string;
+export declare function resolveBuiltinPermission(index: number): ProgressBuiltinPermissionEntry | undefined;
+export declare function isOrderHolderForward(puzzle: ProgressPuzzle): boolean;
+export declare function getRelevantDimensions(action: ProgressIntentPuzzle["action"]): ProgressPuzzleDimension[];

package/dist/knowledge/progress-puzzle.js

@@ -0,0 +1,219 @@
+import { MAX_NAMED_OPERATOR_ADDRESS_COUNT, } from "@wowok/wowok";
+import { getBuiltinPermissionByIndex, } from "./progress-ledger.js";
+export function initPuzzleFromIntent(intent) {
+    const puzzle = {};
+    if (intent.action || intent.rule_sentence) {
+        puzzle.intent = {
+            action: intent.action ?? "operate",
+            target_progress: intent.target_progress,
+            rule_sentence: intent.rule_sentence ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        };
+    }
+    puzzle.constraints = {
+        F_PR_01_machine_published: false,
+        F_PR_02_machine_bound: false,
+        F_PR_03_named_operator_count_le_60: true,
+        F_PR_04_named_operator_addr_le_80: true,
+        F_PR_05_context_repository_le_30: true,
+        F_PR_06_task_one_time: true,
+        F_PR_07_forward_exists_in_machine: false,
+        F_PR_08_holder_match_for_unhold: true,
+    };
+    return puzzle;
+}
+export function checkPuzzleCompleteness(puzzle) {
+    const missing = [];
+    const missing_details = [];
+    if (!puzzle.intent) {
+        missing.push("A");
+        missing_details.push({ dimension: "A", reason: "Intent not specified (action + rule_sentence)" });
+    }
+    else if (!puzzle.intent.rule_sentence) {
+        missing.push("A");
+        missing_details.push({ dimension: "A", reason: "rule_sentence is empty" });
+    }
+    const isQueryOnly = puzzle.intent?.action === "query";
+    if (!isQueryOnly) {
+        if (!puzzle.workflow) {
+            missing.push("B");
+            missing_details.push({ dimension: "B", reason: "Workflow not specified (machine + current_node)" });
+        }
+        else if (!puzzle.workflow.machine) {
+            missing.push("B");
+            missing_details.push({ dimension: "B", reason: "machine address missing" });
+        }
+        else if (!puzzle.workflow.machine_published) {
+            missing.push("B");
+            missing_details.push({ dimension: "B", reason: "Machine not published — Progress requires published Machine" });
+        }
+    }
+    if (puzzle.intent?.action === "named_operator") {
+        if (!puzzle.named_operator) {
+            missing.push("C");
+            missing_details.push({ dimension: "C", reason: "named_operator config not specified (name + op + addresses)" });
+        }
+        else if (!puzzle.named_operator.name && !puzzle.named_operator.is_order_holder_namespace) {
+            missing.push("C");
+            missing_details.push({ dimension: "C", reason: "named_operator.name is empty (use is_order_holder_namespace=true for OrderHolder)" });
+        }
+    }
+    if (puzzle.intent?.action === "task_set") {
+        if (!puzzle.task) {
+            missing.push("D");
+            missing_details.push({ dimension: "D", reason: "Task data not specified (task_address + immutability_acknowledged)" });
+        }
+        else if (!puzzle.task.task_address) {
+            missing.push("D");
+            missing_details.push({ dimension: "D", reason: "task_address missing" });
+        }
+        else if (!puzzle.task.immutability_acknowledged) {
+            missing.push("D");
+            missing_details.push({ dimension: "D", reason: "immutability_acknowledged=false — user must acknowledge task is one-time" });
+        }
+    }
+    if (!puzzle.permission) {
+        missing.push("E");
+        missing_details.push({ dimension: "E", reason: "Permission config not specified (builtin_indexes / forward_permission_index / passport)" });
+    }
+    if (!puzzle.constraints) {
+        missing.push("F");
+        missing_details.push({ dimension: "F", reason: "Constraints not checked" });
+    }
+    return {
+        dimensions: ["A", "B", "C", "D", "E", "F"],
+        missing,
+        missing_details,
+        complete: missing.length === 0,
+        next_step: missing.length === 0
+            ? "Puzzle complete — ready for confirmation text generation"
+            : `Next: complete dimension ${missing[0]} — ${missing_details[0].reason}`,
+    };
+}
+export function validateConstraints(puzzle) {
+    const violations = [];
+    if (puzzle.workflow && !puzzle.workflow.machine_published) {
+        violations.push({
+            constraint_id: "F-PR-01",
+            severity: "CRITICAL",
+            message: `Machine ${puzzle.workflow.machine} is not published — Progress requires a published Machine`,
+            current_value: "unpublished",
+            limit: "published",
+        });
+    }
+    if (puzzle.named_operator) {
+        if (puzzle.named_operator.addresses.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+            violations.push({
+                constraint_id: "F-PR-04",
+                severity: "HIGH",
+                message: `named_operator "${puzzle.named_operator.name}" has ${puzzle.named_operator.addresses.length} addresses, exceeds MAX_NAMED_OPERATOR_ADDRESS_COUNT ${MAX_NAMED_OPERATOR_ADDRESS_COUNT}`,
+                current_value: puzzle.named_operator.addresses.length,
+                limit: MAX_NAMED_OPERATOR_ADDRESS_COUNT,
+            });
+        }
+    }
+    if (puzzle.task && !puzzle.task.immutability_acknowledged) {
+        violations.push({
+            constraint_id: "F-PR-06",
+            severity: "HIGH",
+            message: "Task immutability not acknowledged — task is one-time, E_TASK_ALREADY_SET blocks reset",
+            current_value: "not_acknowledged",
+            limit: "acknowledged",
+        });
+    }
+    if (puzzle.intent?.action === "operate" &&
+        puzzle.intent.rule_sentence.toLowerCase().includes("unhold") &&
+        puzzle.constraints &&
+        !puzzle.constraints.F_PR_08_holder_match_for_unhold) {
+        violations.push({
+            constraint_id: "F-PR-08",
+            severity: "HIGH",
+            message: "unhold requires sender == holder OR sender has 224 permission (adminUnhold)",
+        });
+    }
+    return violations;
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [];
+    lines.push("═══ Progress Confirmation ═══");
+    lines.push("");
+    if (puzzle.intent) {
+        lines.push(`Action: ${puzzle.intent.action}`);
+        if (puzzle.intent.target_progress)
+            lines.push(`Target Progress: ${puzzle.intent.target_progress}`);
+        lines.push(`Rule: ${puzzle.intent.rule_sentence}`);
+        if (puzzle.intent.failure_conditions.length > 0) {
+            lines.push("Failure conditions:");
+            for (const fc of puzzle.intent.failure_conditions)
+                lines.push(`  - ${fc}`);
+        }
+        lines.push("");
+    }
+    if (puzzle.workflow) {
+        lines.push("─ Workflow ──────────────");
+        lines.push(`Machine: ${puzzle.workflow.machine} (published: ${puzzle.workflow.machine_published ? "YES" : "NO"})`);
+        lines.push(`Order/Task: ${puzzle.workflow.order ?? "(not bound)"}`);
+        lines.push(`Current node: ${puzzle.workflow.current_node}`);
+        if (puzzle.workflow.forward_target) {
+            lines.push(`Forward target: ${puzzle.workflow.current_node} --(${puzzle.workflow.forward_target.forward})--> ${puzzle.workflow.forward_target.next_node_name}`);
+        }
+        lines.push(`Use order variant: ${puzzle.workflow.use_order_variant ? "YES (order_next / order_hold)" : "NO (next / hold)"}`);
+        lines.push("");
+    }
+    if (puzzle.named_operator) {
+        lines.push("─ Named Operator ──────────────");
+        lines.push(`Name: "${puzzle.named_operator.name}"${puzzle.named_operator.is_order_holder_namespace ? " (OrderHolder namespace)" : ""}`);
+        lines.push(`Op: ${puzzle.named_operator.op}`);
+        lines.push(`Addresses (${puzzle.named_operator.addresses.length}/${MAX_NAMED_OPERATOR_ADDRESS_COUNT}): ${puzzle.named_operator.addresses.join(", ")}`);
+        lines.push("");
+    }
+    if (puzzle.task) {
+        lines.push("─ Task ──────────────");
+        lines.push(`Task address: ${puzzle.task.task_address}`);
+        if (puzzle.task.submitted_data) {
+            lines.push(`Submitted data (${puzzle.task.submitted_data.type}): ${puzzle.task.submitted_data.payload.slice(0, 80)}${puzzle.task.submitted_data.payload.length > 80 ? "…" : ""}`);
+        }
+        lines.push(`Immutability acknowledged: ${puzzle.task.immutability_acknowledged ? "YES" : "NO"}`);
+        lines.push("");
+    }
+    if (puzzle.permission) {
+        lines.push("─ Permission ──────────────");
+        if (puzzle.permission.builtin_indexes_used.length > 0) {
+            lines.push("Builtin indexes used (management):");
+            for (const p of puzzle.permission.builtin_indexes_used) {
+                lines.push(`  [${p.index}] ${p.name}: ${p.description}`);
+            }
+        }
+        if (puzzle.permission.forward_permission_index !== null) {
+            lines.push(`Forward.permissionIndex: ${puzzle.permission.forward_permission_index}`);
+        }
+        lines.push(`Named operator short-circuit: ${puzzle.permission.uses_named_operator_short_circuit ? "YES" : "NO"}`);
+        lines.push(`Requires Passport: ${puzzle.permission.requires_passport ? "YES" : "NO"}`);
+        lines.push(`Uses order.has_op_permission: ${puzzle.permission.uses_order_permission ? "YES" : "NO"}`);
+        lines.push("");
+    }
+    const violations = validateConstraints(puzzle);
+    if (violations.length > 0) {
+        lines.push("─ Constraint Violations ──────────────");
+        for (const v of violations)
+            lines.push(`  [${v.severity}] ${v.constraint_id}: ${v.message}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function resolveBuiltinPermission(index) {
+    return getBuiltinPermissionByIndex(index);
+}
+export function isOrderHolderForward(puzzle) {
+    return (puzzle.permission?.uses_named_operator_short_circuit === false &&
+        puzzle.permission?.forward_permission_index === null &&
+        puzzle.workflow?.use_order_variant === true);
+}
+export function getRelevantDimensions(action) {
+    const base = ["A", "B", "E", "F"];
+    if (action === "named_operator")
+        base.push("C");
+    if (action === "task_set")
+        base.push("D");
+    return base;
+}