@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/permission-puzzle.js

@@ -0,0 +1,173 @@
+import { USER_DEFINED_PERM_INDEX_START, MAX_ENTITY_COUNT, MAX_PERM_FOR_ENTITY, MAX_ADMIN_COUNT, } from "@wowok/wowok";
+import { isBuiltinPermission, } from "./permission-ledger.js";
+export function initPuzzleFromIntent(intent) {
+    const puzzle = {};
+    if (intent.action || intent.rule_sentence) {
+        puzzle.intent = {
+            action: intent.action ?? "create",
+            target_object: intent.target_object,
+            rule_sentence: intent.rule_sentence ?? "",
+            failure_conditions: intent.failure_conditions ?? [],
+        };
+    }
+    puzzle.constraints = {
+        F_P_01_custom_index_ge_1000: true,
+        F_P_02_entity_count_le_1000: true,
+        F_P_03_perm_count_per_entity_le_1000: true,
+        F_P_04_admin_count_le_500: true,
+        F_P_05_owner_address_valid: true,
+        F_P_06_owner_only_for_assert_owner: true,
+        F_P_07_admin_only_for_assert_admin: 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" });
+    }
+    if (!puzzle.binding) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "Binding not specified (owner + admins)" });
+    }
+    else if (!puzzle.binding.owner) {
+        missing.push("B");
+        missing_details.push({ dimension: "B", reason: "owner address missing" });
+    }
+    if (!puzzle.data_source && puzzle.intent?.action === "create") {
+        missing.push("C");
+        missing_details.push({ dimension: "C", reason: "Data source not specified (entities + permissions)" });
+    }
+    if (!puzzle.operations) {
+        missing.push("D");
+        missing_details.push({ dimension: "D", reason: "Operations not enumerated" });
+    }
+    if (!puzzle.logic) {
+        missing.push("E");
+        missing_details.push({ dimension: "E", reason: "Logic flow not defined" });
+    }
+    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.data_source)
+        return violations;
+    for (const entity of puzzle.data_source.entities) {
+        for (const idx of entity.permission_indexes) {
+            if (idx < USER_DEFINED_PERM_INDEX_START && !isBuiltinPermission(idx)) {
+                violations.push({
+                    constraint_id: "F-P-01",
+                    severity: "CRITICAL",
+                    message: `Permission index ${idx} for entity ${entity.address} is < ${USER_DEFINED_PERM_INDEX_START} and not a builtin permission`,
+                    current_value: idx,
+                    limit: USER_DEFINED_PERM_INDEX_START,
+                });
+            }
+        }
+    }
+    if (puzzle.data_source.entities.length > MAX_ENTITY_COUNT) {
+        violations.push({
+            constraint_id: "F-P-02",
+            severity: "HIGH",
+            message: `Entity count ${puzzle.data_source.entities.length} exceeds MAX_ENTITY_COUNT ${MAX_ENTITY_COUNT}`,
+            current_value: puzzle.data_source.entities.length,
+            limit: MAX_ENTITY_COUNT,
+        });
+    }
+    for (const entity of puzzle.data_source.entities) {
+        if (entity.permission_indexes.length > MAX_PERM_FOR_ENTITY) {
+            violations.push({
+                constraint_id: "F-P-03",
+                severity: "HIGH",
+                message: `Entity ${entity.address} has ${entity.permission_indexes.length} permissions, exceeds MAX_PERM_FOR_ENTITY ${MAX_PERM_FOR_ENTITY}`,
+                current_value: entity.permission_indexes.length,
+                limit: MAX_PERM_FOR_ENTITY,
+            });
+        }
+    }
+    if (puzzle.binding && puzzle.binding.admins.length > MAX_ADMIN_COUNT) {
+        violations.push({
+            constraint_id: "F-P-04",
+            severity: "HIGH",
+            message: `Admin count ${puzzle.binding.admins.length} exceeds MAX_ADMIN_COUNT ${MAX_ADMIN_COUNT}`,
+            current_value: puzzle.binding.admins.length,
+            limit: MAX_ADMIN_COUNT,
+        });
+    }
+    return violations;
+}
+export function generateConfirmationText(puzzle) {
+    const lines = [];
+    lines.push("═══ Permission Confirmation ═══");
+    lines.push("");
+    if (puzzle.intent) {
+        lines.push(`Action: ${puzzle.intent.action}`);
+        if (puzzle.intent.target_object)
+            lines.push(`Target: ${puzzle.intent.target_object}`);
+        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.binding) {
+        lines.push("─ Binding ──────────────");
+        lines.push(`Owner: ${puzzle.binding.owner}`);
+        lines.push(`Admins (${puzzle.binding.admins.length}): ${puzzle.binding.admins.join(", ")}`);
+        if (puzzle.binding.um !== undefined) {
+            lines.push(`UM: ${puzzle.binding.um ?? "(none)"}`);
+        }
+        if (puzzle.binding.applied_to && puzzle.binding.applied_to.length > 0) {
+            lines.push(`Applied to: ${puzzle.binding.applied_to.join(", ")}`);
+        }
+        lines.push("");
+    }
+    if (puzzle.data_source) {
+        lines.push("─ Data Source ──────────────");
+        lines.push(`Entities: ${puzzle.data_source.entities.length}`);
+        for (const e of puzzle.data_source.entities) {
+            lines.push(`  ${e.address} (${e.type}): indexes [${e.permission_indexes.join(", ")}]`);
+        }
+        if (puzzle.data_source.custom_permissions_defined.length > 0) {
+            lines.push("Custom permissions:");
+            for (const cp of puzzle.data_source.custom_permissions_defined) {
+                lines.push(`  [${cp.index}] ${cp.name}: ${cp.description}`);
+            }
+        }
+        lines.push("");
+    }
+    if (puzzle.operations && puzzle.operations.operations.length > 0) {
+        lines.push("─ Operations ──────────────");
+        for (const op of puzzle.operations.operations)
+            lines.push(`  - ${JSON.stringify(op)}`);
+        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");
+}

package/dist/knowledge/permission-risk.d.ts

@@ -0,0 +1,76 @@
+import { type PermissionScene } from "./permission-ledger.js";
+export type RiskLevel = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+export type RiskCategory = "structural" | "semantic" | "authority" | "lifecycle" | "cross_object";
+export interface PermissionRisk {
+    id: string;
+    level: RiskLevel;
+    category: RiskCategory;
+    title: string;
+    description: string;
+    affected_stakeholders: PermissionStakeholder[];
+    scenario: string;
+    mitigation: string;
+    evidence?: string;
+}
+export type PermissionStakeholder = "owner" | "admin" | "entity" | "user" | "system";
+export interface RiskRule {
+    id: string;
+    category: RiskCategory;
+    trigger: string;
+    check: (ctx: RiskCheckContext) => PermissionRisk | null;
+}
+export interface RiskCheckContext {
+    object?: string | null;
+    description?: string;
+    admin?: {
+        op: "add" | "remove" | "set";
+        addresses: string[];
+    };
+    table?: {
+        op: "add perm by index" | "set perm by index" | "remove perm by index";
+        index: number;
+        entity: string[];
+    } | {
+        op: "add perm by entity" | "set perm by entity" | "remove perm by entity";
+        entity: string;
+        index: number[];
+    };
+    entity?: {
+        op: "swap" | "replace" | "copy";
+        entity1: string;
+        entity2: string;
+    } | {
+        op: "del";
+        entity: string;
+    };
+    remark?: {
+        op: "set";
+        index: number;
+        remark: string;
+    } | {
+        op: "remove";
+        index: number;
+    } | {
+        op: "clear";
+    };
+    apply?: string[];
+    builder?: string;
+    um?: string | null;
+    current_admin_count?: number;
+    current_entity_count?: number;
+    target_objects_types?: string[];
+}
+export declare const PERMISSION_RISK_VERSION = "1.0.0";
+export declare function getAllRiskRules(): RiskRule[];
+export declare function getRiskRulesCount(): number;
+export declare function getRiskRulesByCategory(category: RiskCategory): RiskRule[];
+export interface PermissionRiskAssessment {
+    summary: string;
+    scene?: PermissionScene;
+    risks: PermissionRisk[];
+    overall_risk: RiskLevel;
+    risks_by_category: Partial<Record<RiskCategory, number>>;
+    stakeholder_advice: Partial<Record<PermissionStakeholder, string[]>>;
+    needs_human_review: boolean;
+}
+export declare function assessPermissionRisks(ctx: RiskCheckContext): PermissionRiskAssessment;

package/dist/knowledge/permission-risk.js

@@ -0,0 +1,411 @@
+import { USER_DEFINED_PERM_INDEX_START, MAX_ENTITY_COUNT, MAX_PERM_FOR_ENTITY, MAX_ADMIN_COUNT, } from "@wowok/wowok";
+import { isBuiltinPermission, findSceneByPermissionIndex, } from "./permission-ledger.js";
+const R_P_01 = {
+    id: "R-P-1-01",
+    category: "structural",
+    trigger: "Custom permission index < USER_DEFINED_PERM_INDEX_START (1000) and not builtin",
+    check: (ctx) => {
+        if (!ctx.table)
+            return null;
+        if ("index" in ctx.table && typeof ctx.table.index === "number") {
+            const idx = ctx.table.index;
+            if (idx < USER_DEFINED_PERM_INDEX_START && !isBuiltinPermission(idx)) {
+                return {
+                    id: "R-P-1-01",
+                    level: "CRITICAL",
+                    category: "structural",
+                    title: "Invalid permission index (< 1000 and not builtin)",
+                    description: `Permission index ${idx} is below USER_DEFINED_PERM_INDEX_START (${USER_DEFINED_PERM_INDEX_START}) and not a builtin permission. Custom indexes must be >= 1000.`,
+                    affected_stakeholders: ["owner", "admin", "system"],
+                    scenario: "User defines a custom permission with index < 1000",
+                    mitigation: `Use index >= ${USER_DEFINED_PERM_INDEX_START} for custom permissions, or use a builtin index if applicable`,
+                    evidence: `index=${idx}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_P_02 = {
+    id: "R-P-1-02",
+    category: "structural",
+    trigger: "Entity count exceeds MAX_ENTITY_COUNT (1000)",
+    check: (ctx) => {
+        const count = ctx.current_entity_count ?? 0;
+        if (count > MAX_ENTITY_COUNT) {
+            return {
+                id: "R-P-1-02",
+                level: "HIGH",
+                category: "structural",
+                title: "Entity count exceeds limit",
+                description: `Permission has ${count} entities, exceeds MAX_ENTITY_COUNT ${MAX_ENTITY_COUNT}`,
+                affected_stakeholders: ["owner", "admin"],
+                scenario: "Adding entities beyond the protocol limit",
+                mitigation: "Split into multiple Permission objects or remove inactive entities",
+                evidence: `entity_count=${count}`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_03 = {
+    id: "R-P-1-03",
+    category: "structural",
+    trigger: "Per-entity permission count exceeds MAX_PERM_FOR_ENTITY (1000)",
+    check: (ctx) => {
+        if (ctx.table && "index" in ctx.table && Array.isArray(ctx.table.index)) {
+            if (ctx.table.index.length > MAX_PERM_FOR_ENTITY) {
+                return {
+                    id: "R-P-1-03",
+                    level: "HIGH",
+                    category: "structural",
+                    title: "Per-entity permission count exceeds limit",
+                    description: `Entity ${ctx.table.entity} has ${ctx.table.index.length} permissions, exceeds MAX_PERM_FOR_ENTITY ${MAX_PERM_FOR_ENTITY}`,
+                    affected_stakeholders: ["entity", "admin"],
+                    scenario: "Granting too many permissions to one entity",
+                    mitigation: "Consolidate similar permissions or split entity into multiple roles",
+                    evidence: `perm_count=${ctx.table.index.length}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_P_04 = {
+    id: "R-P-1-04",
+    category: "structural",
+    trigger: "Admin count exceeds MAX_ADMIN_COUNT (500)",
+    check: (ctx) => {
+        if (ctx.admin) {
+            const newCount = ctx.admin.op === "add"
+                ? (ctx.current_admin_count ?? 0) + ctx.admin.addresses.length
+                : ctx.admin.addresses.length;
+            if (newCount > MAX_ADMIN_COUNT) {
+                return {
+                    id: "R-P-1-04",
+                    level: "HIGH",
+                    category: "structural",
+                    title: "Admin count exceeds limit",
+                    description: `Admin count would be ${newCount}, exceeds MAX_ADMIN_COUNT ${MAX_ADMIN_COUNT}`,
+                    affected_stakeholders: ["owner", "admin"],
+                    scenario: "Adding too many admins",
+                    mitigation: "Remove inactive admins before adding new ones",
+                    evidence: `admin_count=${newCount}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_P_2_01 = {
+    id: "R-P-2-01",
+    category: "semantic",
+    trigger: "Builtin permission index used outside its host object scene",
+    check: (ctx) => {
+        if (!ctx.table || !("index" in ctx.table) || typeof ctx.table.index !== "number")
+            return null;
+        const idx = ctx.table.index;
+        if (!isBuiltinPermission(idx))
+            return null;
+        const scene = findSceneByPermissionIndex(idx);
+        if (!scene)
+            return null;
+        if (ctx.target_objects_types && ctx.target_objects_types.length > 0) {
+            const mismatched = ctx.target_objects_types.filter(t => t !== scene.host_object);
+            if (mismatched.length > 0) {
+                return {
+                    id: "R-P-2-01",
+                    level: "HIGH",
+                    category: "semantic",
+                    title: "Permission index host object mismatch",
+                    description: `Permission ${idx} (${scene.builtin_indexes.find(p => p.index === idx)?.name}) is for ${scene.host_object}, but apply targets: ${mismatched.join(", ")}`,
+                    affected_stakeholders: ["owner", "admin"],
+                    scenario: "Using SERVICE_* index on Machine object",
+                    mitigation: `Use ${scene.host_object}-specific permission indexes for ${mismatched.join(", ")}`,
+                    evidence: `index=${idx}, targets=${mismatched.join(",")}`,
+                };
+            }
+        }
+        return null;
+    },
+};
+const R_P_2_02 = {
+    id: "R-P-2-02",
+    category: "semantic",
+    trigger: "Custom permission (>= 1000) without remark",
+    check: (ctx) => {
+        if (!ctx.table || !("index" in ctx.table) || typeof ctx.table.index !== "number")
+            return null;
+        const idx = ctx.table.index;
+        if (idx < USER_DEFINED_PERM_INDEX_START)
+            return null;
+        if (ctx.remark && ctx.remark.op === "set" && ctx.remark.index === idx)
+            return null;
+        return {
+            id: "R-P-2-02",
+            level: "LOW",
+            category: "semantic",
+            title: "Custom permission without remark",
+            description: `Custom permission ${idx} has no remark; future maintainers won't know its purpose`,
+            affected_stakeholders: ["admin"],
+            scenario: "Adding custom permission without documentation",
+            mitigation: `Add remark: { op: "set", index: ${idx}, remark: "<purpose>" }`,
+            evidence: `index=${idx}`,
+        };
+    },
+};
+const R_P_3_01 = {
+    id: "R-P-3-01",
+    category: "authority",
+    trigger: "Permission over-concentration: owner is the only admin",
+    check: (ctx) => {
+        if (!ctx.admin || ctx.admin.op !== "set")
+            return null;
+        if (ctx.admin.addresses.length === 1) {
+            return {
+                id: "R-P-3-01",
+                level: "MEDIUM",
+                category: "authority",
+                title: "Permission over-concentration",
+                description: "Only one admin (likely owner); loss of owner key means permanent lockout",
+                affected_stakeholders: ["owner"],
+                scenario: "Single-admin Permission",
+                mitigation: "Add 1-2 backup admins with limited permission indexes",
+                evidence: `admin_count=1`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_3_02 = {
+    id: "R-P-3-02",
+    category: "authority",
+    trigger: "Permission over-dispersion: admin count > 50",
+    check: (ctx) => {
+        if (!ctx.admin)
+            return null;
+        const count = ctx.admin.op === "set" ? ctx.admin.addresses.length : (ctx.current_admin_count ?? 0);
+        if (count > 50) {
+            return {
+                id: "R-P-3-02",
+                level: "MEDIUM",
+                category: "authority",
+                title: "Permission over-dispersion",
+                description: `${count} admins increases coordination cost and key-management risk`,
+                affected_stakeholders: ["owner", "admin"],
+                scenario: "Large admin committee",
+                mitigation: "Use multi-sig or hierarchical admin structure",
+                evidence: `admin_count=${count}`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_3_03 = {
+    id: "R-P-3-03",
+    category: "authority",
+    trigger: "UM is owner self-reference",
+    check: (ctx) => {
+        if (ctx.um === undefined || ctx.um === null)
+            return null;
+        if (ctx.builder && ctx.um === ctx.builder) {
+            return {
+                id: "R-P-3-03",
+                level: "MEDIUM",
+                category: "authority",
+                title: "UM is owner self-reference",
+                description: "Setting UM to owner address defeats separation of concerns",
+                affected_stakeholders: ["owner"],
+                scenario: "Owner delegates UM to self",
+                mitigation: "Use a separate Contact object address for UM",
+                evidence: `um=${ctx.um}`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_4_01 = {
+    id: "R-P-4-01",
+    category: "lifecycle",
+    trigger: "Ownership transfer operation (builder field set)",
+    check: (ctx) => {
+        if (!ctx.builder)
+            return null;
+        return {
+            id: "R-P-4-01",
+            level: "HIGH",
+            category: "lifecycle",
+            title: "Ownership transfer — irreversible",
+            description: `Transferring Permission to ${ctx.builder}. Once executed, original owner loses ALL control permanently.`,
+            affected_stakeholders: ["owner"],
+            scenario: "Owner transfers Permission to new address",
+            mitigation: "1) Verify new owner address twice. 2) Export Permission JSON before transfer. 3) Coordinate with new owner to confirm receipt.",
+            evidence: `new_owner=${ctx.builder}`,
+        };
+    },
+};
+const R_P_4_02 = {
+    id: "R-P-4-02",
+    category: "lifecycle",
+    trigger: "Apply to multiple objects at once",
+    check: (ctx) => {
+        if (!ctx.apply || ctx.apply.length === 0)
+            return null;
+        if (ctx.apply.length > 3) {
+            return {
+                id: "R-P-4-02",
+                level: "MEDIUM",
+                category: "lifecycle",
+                title: "Batch apply to multiple objects",
+                description: `Applying Permission to ${ctx.apply.length} objects at once; if any object type mismatches, transaction may fail or silently misalign`,
+                affected_stakeholders: ["owner"],
+                scenario: "Batch apply across heterogeneous objects",
+                mitigation: "Apply to 1-3 objects at a time; verify each object type matches permission indexes",
+                evidence: `apply_count=${ctx.apply.length}`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_4_03 = {
+    id: "R-P-4-03",
+    category: "lifecycle",
+    trigger: "Entity replace operation (destructive)",
+    check: (ctx) => {
+        if (!ctx.entity || ctx.entity.op !== "replace")
+            return null;
+        return {
+            id: "R-P-4-03",
+            level: "MEDIUM",
+            category: "lifecycle",
+            title: "Entity replace — destructive",
+            description: `Replacing ${ctx.entity.entity1} with ${ctx.entity.entity2}; entity1 loses ALL permissions permanently`,
+            affected_stakeholders: ["entity"],
+            scenario: "Replacing a user who left the organization",
+            mitigation: "Prefer 'copy' over 'replace' if entity1 should retain permissions",
+            evidence: `entity1=${ctx.entity.entity1}, entity2=${ctx.entity.entity2}`,
+        };
+    },
+};
+const R_P_5_01 = {
+    id: "R-P-5-01",
+    category: "cross_object",
+    trigger: "Apply to Progress object (Permission becomes immutable on bind)",
+    check: (ctx) => {
+        if (!ctx.apply)
+            return null;
+        if (ctx.target_objects_types?.includes("Progress")) {
+            return {
+                id: "R-P-5-01",
+                level: "MEDIUM",
+                category: "cross_object",
+                title: "Apply to Progress — post-bind mutability limited",
+                description: "Once Permission is bound to Progress (which binds Machine), permission table changes may not affect already-published Machine workflow",
+                affected_stakeholders: ["owner"],
+                scenario: "Permission shared across Machine/Progress",
+                mitigation: "Configure all permission indexes before Machine publish",
+                evidence: `target=Progress`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_5_02 = {
+    id: "R-P-5-02",
+    category: "cross_object",
+    trigger: "Permission reused across multiple host object types",
+    check: (ctx) => {
+        if (!ctx.target_objects_types || ctx.target_objects_types.length < 2)
+            return null;
+        const uniqueTypes = new Set(ctx.target_objects_types);
+        if (uniqueTypes.size > 1) {
+            return {
+                id: "R-P-5-02",
+                level: "MEDIUM",
+                category: "cross_object",
+                title: "Permission shared across heterogeneous objects",
+                description: `Single Permission applied to ${[...uniqueTypes].join(", ")}; permission indexes may have different semantics per object`,
+                affected_stakeholders: ["owner", "admin"],
+                scenario: "One Permission for both Service and Treasury",
+                mitigation: "Use separate Permission objects per host object type for clarity",
+                evidence: `types=${[...uniqueTypes].join(",")}`,
+            };
+        }
+        return null;
+    },
+};
+const R_P_5_03 = {
+    id: "R-P-5-03",
+    category: "cross_object",
+    trigger: "Treasury external_*_guard management (255/256) granted — verify guard lists are populated",
+    check: (ctx) => {
+        if (!ctx.table || !("index" in ctx.table) || typeof ctx.table.index !== "number")
+            return null;
+        const idx = ctx.table.index;
+        if (idx === 255 || idx === 256) {
+            return {
+                id: "R-P-5-03",
+                level: "HIGH",
+                category: "cross_object",
+                title: "Treasury external guard management granted — populate guard lists",
+                description: `Permission ${idx} (${idx === 255 ? "TREASURY_EXTERNAL_DEPOSIT_GUARD" : "TREASURY_EXTERNAL_WITHDRAW_GUARD"}) granted; ensure external_${idx === 255 ? "deposit" : "withdraw"}_guard list is populated via external_*_guard_add so external operations are authorized`,
+                affected_stakeholders: ["owner", "admin"],
+                scenario: "External treasury guard management without populated guard lists",
+                mitigation: `Call treasury.external_${idx === 255 ? "deposit" : "withdraw"}_guard_add to register Guard objects; external_deposit/external_withdraw require Guard + Passport (no Permission index)`,
+                evidence: `index=${idx}`,
+            };
+        }
+        return null;
+    },
+};
+const ALL_RULES = [
+    R_P_01, R_P_02, R_P_03, R_P_04,
+    R_P_2_01, R_P_2_02,
+    R_P_3_01, R_P_3_02, R_P_3_03,
+    R_P_4_01, R_P_4_02, R_P_4_03,
+    R_P_5_01, R_P_5_02, R_P_5_03,
+];
+export const PERMISSION_RISK_VERSION = "1.0.0";
+export function getAllRiskRules() {
+    return [...ALL_RULES];
+}
+export function getRiskRulesCount() {
+    return ALL_RULES.length;
+}
+export function getRiskRulesByCategory(category) {
+    return ALL_RULES.filter(r => r.category === category);
+}
+export function assessPermissionRisks(ctx) {
+    const risks = [];
+    for (const rule of ALL_RULES) {
+        const r = rule.check(ctx);
+        if (r)
+            risks.push(r);
+    }
+    const overall = risks.length === 0
+        ? "LOW"
+        : risks.some(r => r.level === "CRITICAL") ? "CRITICAL"
+            : risks.some(r => r.level === "HIGH") ? "HIGH"
+                : risks.some(r => r.level === "MEDIUM") ? "MEDIUM"
+                    : "LOW";
+    const byCategory = {};
+    for (const r of risks) {
+        byCategory[r.category] = (byCategory[r.category] ?? 0) + 1;
+    }
+    const advice = {};
+    for (const r of risks) {
+        for (const s of r.affected_stakeholders) {
+            if (!advice[s])
+                advice[s] = [];
+            advice[s].push(`${r.id}: ${r.mitigation}`);
+        }
+    }
+    return {
+        summary: `Assessed ${risks.length} risk(s) across ${Object.keys(byCategory).length} categories`,
+        risks,
+        overall_risk: overall,
+        risks_by_category: byCategory,
+        stakeholder_advice: advice,
+        needs_human_review: risks.some(r => r.level === "CRITICAL" || r.level === "HIGH"),
+    };
+}