@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/extensions/capability-manifest.js

@@ -0,0 +1,594 @@
+export class CapabilityRegistry {
+    static instance;
+    cards = new Map();
+    edges = [];
+    initialized = false;
+    static Instance() {
+        if (!CapabilityRegistry.instance) {
+            CapabilityRegistry.instance = new CapabilityRegistry();
+        }
+        return CapabilityRegistry.instance;
+    }
+    constructor() {
+        this.registerBuiltins();
+        this.registerBuiltinEdges();
+        this.initialized = true;
+    }
+    registerCard(card) {
+        if (!card.capability_id || !card.object_type || !card.module)
+            return false;
+        this.cards.set(card.capability_id, card);
+        return true;
+    }
+    getCard(capabilityId) {
+        return this.cards.get(capabilityId);
+    }
+    listCards(filter) {
+        let all = Array.from(this.cards.values());
+        if (!filter)
+            return all;
+        if (filter.objectType)
+            all = all.filter(c => c.object_type === filter.objectType);
+        if (filter.module)
+            all = all.filter(c => c.module === filter.module);
+        if (filter.industryAgnostic)
+            all = all.filter(c => c.industry_agnostic === filter.industryAgnostic);
+        if (filter.industry)
+            all = all.filter(c => c.observed_in_industries[filter.industry] !== undefined ||
+                c.industry_overrides?.[filter.industry] !== undefined);
+        return all;
+    }
+    registerEdge(edge) {
+        this.edges.push(edge);
+    }
+    getGraph() {
+        return {
+            nodes: new Map(this.cards),
+            edges: [...this.edges],
+        };
+    }
+    getDependencies(capabilityId) {
+        const visited = new Set();
+        const result = [];
+        const traverse = (id) => {
+            if (visited.has(id))
+                return;
+            visited.add(id);
+            for (const edge of this.edges) {
+                if (edge.from === id && edge.edge_kind === "requires") {
+                    const dep = this.cards.get(edge.to);
+                    if (dep && !visited.has(dep.capability_id)) {
+                        result.push(dep);
+                        traverse(edge.to);
+                    }
+                }
+            }
+        };
+        traverse(capabilityId);
+        return result;
+    }
+    getDependents(capabilityId) {
+        const result = [];
+        for (const edge of this.edges) {
+            if (edge.to === capabilityId && edge.edge_kind === "requires") {
+                const dep = this.cards.get(edge.from);
+                if (dep)
+                    result.push(dep);
+            }
+        }
+        return result;
+    }
+    getCapabilitiesByIndustry(industry) {
+        return this.listCards({ industry });
+    }
+    getCapabilitiesByObject(objectType) {
+        return this.listCards({ objectType });
+    }
+    evaluateMigration(source, target) {
+        const sourceCaps = this.getCapabilitiesByIndustry(source);
+        const targetCaps = this.getCapabilitiesByIndustry(target);
+        const sourceIds = new Set(sourceCaps.map(c => c.capability_id));
+        const targetIds = new Set(targetCaps.map(c => c.capability_id));
+        const covered = [];
+        const missing = [];
+        const conflicting = [];
+        for (const id of sourceIds) {
+            if (targetIds.has(id)) {
+                covered.push(id);
+                const sourceCard = sourceCaps.find(c => c.capability_id === id);
+                const targetCard = targetCaps.find(c => c.capability_id === id);
+                const diff = this.computeConfigDiff(sourceCard.industry_overrides?.[source] ?? sourceCard.config_template, targetCard.industry_overrides?.[target] ?? targetCard.config_template);
+                if (diff.diff_ratio > 0.5) {
+                    conflicting.push({
+                        capability_id: id,
+                        source_config: sourceCard.industry_overrides?.[source] ?? sourceCard.config_template,
+                        target_config: targetCard.industry_overrides?.[target] ?? targetCard.config_template,
+                        diff_summary: diff.summary,
+                    });
+                }
+            }
+        }
+        for (const id of targetIds) {
+            if (!sourceIds.has(id))
+                missing.push(id);
+        }
+        const feasibility_score = covered.length === 0 && missing.length === 0
+            ? 0
+            : Math.round(((covered.length - conflicting.length) / (covered.length + missing.length)) * 100);
+        const recommendations = [];
+        if (missing.length > 0) {
+            recommendations.push(`Missing ${missing.length} capabilities, need to add: ${missing.slice(0, 5).join(", ")}${missing.length > 5 ? "..." : ""}`);
+        }
+        if (conflicting.length > 0) {
+            recommendations.push(`Detected ${conflicting.length} capabilities with large parameter differences, need to rewrite configuration`);
+        }
+        if (feasibility_score >= 80) {
+            recommendations.push("Migration feasibility is high, most capabilities can be reused directly");
+        }
+        else if (feasibility_score >= 50) {
+            recommendations.push("Migration feasibility is medium, need to supplement or rewrite some capabilities");
+        }
+        else {
+            recommendations.push("Migration feasibility is low, recommend regenerating the plan based on the target industry template");
+        }
+        return {
+            feasibility_score,
+            covered_capabilities: covered,
+            missing_capabilities: missing,
+            conflicting_capabilities: conflicting,
+            recommendations,
+        };
+    }
+    findPurityViolations() {
+        return Array.from(this.cards.values()).filter(c => {
+            if (c.industry_agnostic !== "high")
+                return false;
+            const overrideCount = c.industry_overrides ? Object.keys(c.industry_overrides).length : 0;
+            return overrideCount >= 3;
+        });
+    }
+    recordUsage(capabilityId, industry) {
+        const card = this.cards.get(capabilityId);
+        if (!card)
+            return;
+        if (!card.observed_in_industries[industry]) {
+            card.observed_in_industries[industry] = 0;
+        }
+        card.observed_in_industries[industry]++;
+    }
+    recordSuccess(capabilityId) {
+        const card = this.cards.get(capabilityId);
+        if (card)
+            card.success_count++;
+    }
+    recordFailure(capabilityId, reason) {
+        const card = this.cards.get(capabilityId);
+        if (!card)
+            return;
+        card.failure_count++;
+        if (reason && !card.known_failure_modes.includes(reason)) {
+            card.known_failure_modes.push(reason);
+        }
+    }
+    recordVerificationReport(report) {
+        for (const capId of report.capabilities_used) {
+            this.recordUsage(capId, report.industry);
+            if (report.result === "success") {
+                this.recordSuccess(capId);
+            }
+            else if (report.result === "failure") {
+                const reason = report.failure_reasons?.[0] ?? "unknown failure";
+                this.recordFailure(capId, reason);
+            }
+        }
+    }
+    getCapabilitiesForExtension(capabilitiesUsed) {
+        return capabilitiesUsed
+            .map(id => this.cards.get(id))
+            .filter((c) => c !== undefined);
+    }
+    evaluateExtensionCoverage(industry, capabilitiesUsed) {
+        const declared = capabilitiesUsed.length;
+        const industryCaps = this.getCapabilitiesByIndustry(industry);
+        const expected = industryCaps.length || declared;
+        const missing = industryCaps
+            .filter(c => !capabilitiesUsed.includes(c.capability_id))
+            .map(c => c.capability_id);
+        const coverage = expected === 0 ? 100 : Math.round((declared / expected) * 100);
+        return {
+            industry,
+            declared_count: declared,
+            expected_count: expected,
+            coverage_percentage: Math.min(coverage, 100),
+            missing_capabilities: missing,
+        };
+    }
+    registerBuiltins() {
+        this.registerCard({
+            capability_id: "permission.index_create",
+            display_name: "Permission Index Create",
+            description: "Create role permission index, supports multi-role permission assignment such as merchant/customer/arbiter",
+            object_type: "permission", module: "handler", category: "trust",
+            industry_agnostic: "high",
+            config_template: {
+                permission_indexes: [
+                    { name: "merchant", description: "Service owner" },
+                    { name: "customer", description: "Service buyer" },
+                ],
+            },
+            industry_overrides: {
+                education: { permission_indexes: [
+                        { name: "teacher", description: "Course provider" },
+                        { name: "student", description: "Course consumer" },
+                        { name: "parent", description: "Guardian (minor)" },
+                    ] },
+                travel: { permission_indexes: [
+                        { name: "guide", description: "Tour guide" },
+                        { name: "tourist", description: "Tour participant" },
+                    ] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: [], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "permission.role_assign",
+            display_name: "Permission Role Assign",
+            description: "Assign role permission index to objects (Machine/Service/Allocation)",
+            object_type: "permission", module: "handler", category: "trust",
+            industry_agnostic: "high",
+            config_template: { target_object: "<obj>", role: "<role_name>" },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["permission.index_create"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "guard.validate_buy",
+            display_name: "Guard Validate Buy",
+            description: "Order validation: check buyer eligibility, order parameters, inventory and other conditions",
+            object_type: "guard", module: "handler", category: "validation",
+            industry_agnostic: "medium",
+            config_template: { host: "service", templates: [] },
+            industry_overrides: {
+                retail: { templates: ["tpl_check_inventory", "tpl_check_buyer_address"] },
+                freelance: { templates: ["tpl_check_buyer_budget", "tpl_check_freelancer_available"] },
+                rental: { templates: ["tpl_check_deposit", "tpl_check_item_available"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["permission.index_create"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "guard.validate_wip_hash",
+            display_name: "Guard Validate WIP Hash",
+            description: "Validate WIP (Work-In-Progress) hash, used for milestone validation of digital deliverables",
+            object_type: "guard", module: "handler", category: "evidence",
+            industry_agnostic: "low",
+            config_template: { host: "machine", templates: ["tpl_validate_wip_hash"] },
+            industry_overrides: {
+                freelance: { templates: ["tpl_validate_wip_hash", "tpl_validate_deliverable_format"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["milestone mode requires WIP hash evidence — without WIP, allocation cannot advance"],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "machine.node_topology",
+            display_name: "Machine Node Topology",
+            description: "Workflow node topology: define the state machine from order creation to completion",
+            object_type: "machine", module: "templates", category: "workflow",
+            industry_agnostic: "low",
+            config_template: {
+                nodes: [
+                    { name: "paid", role: "Entry: order created and paid" },
+                    { name: "delivering", role: "Service delivery in progress" },
+                    { name: "completed", role: "Service completed, funds released" },
+                    { name: "refunded", role: "Customer refund path" },
+                    { name: "cancelled", role: "Pre-delivery cancellation" },
+                ],
+            },
+            industry_overrides: {
+                retail: { nodes: [
+                        { name: "paid", role: "Order paid" },
+                        { name: "shipped", role: "Goods shipped" },
+                        { name: "delivered", role: "Goods delivered" },
+                        { name: "confirmed", role: "Buyer confirms receipt" },
+                        { name: "completed", role: "Funds released" },
+                        { name: "refunded", role: "Return & refund" },
+                        { name: "cancelled", role: "Pre-ship cancellation" },
+                    ] },
+                freelance: { nodes: [
+                        { name: "paid", role: "Order paid (escrow)" },
+                        { name: "in_progress", role: "Freelancer working" },
+                        { name: "submitted", role: "Work submitted for review" },
+                        { name: "accepted", role: "Buyer accepts deliverable" },
+                        { name: "completed", role: "Funds released" },
+                        { name: "revision", role: "Revision requested" },
+                        { name: "refunded", role: "Refund path" },
+                        { name: "cancelled", role: "Pre-start cancellation" },
+                    ] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["permission.index_create"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "treasury.owner_receive",
+            display_name: "Treasury Owner Receive",
+            description: "Fund escrow: supports owner_receive mode, funds go directly into the object owner wallet",
+            object_type: "treasury", module: "handler", category: "fund_flow",
+            industry_agnostic: "high",
+            config_template: { owner_receive: true },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: [], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "allocation.distribute",
+            display_name: "Multi-tier Allocation Distribution",
+            description: "Multi-tier allocation: supports distributing funds to multiple recipients by ratio / by order / by condition",
+            object_type: "allocation", module: "handler", category: "fund_flow",
+            industry_agnostic: "medium",
+            config_template: {
+                strategy: { recipient: "entity", count: 1, mode: "surplus", description: "Default: all to service owner" },
+            },
+            industry_overrides: {
+                retail: { strategy: { recipient: "entity", count: 2, mode: "rate", description: "Platform 10% + Merchant 90%" } },
+                freelance: { strategy: { recipient: "entity", count: 2, mode: "milestone", description: "50% upfront + 50% on delivery" } },
+                travel: { strategy: { recipient: "entity", count: 3, mode: "rate", description: "Guide 60% + Platform 30% + Insurance 10%" } },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["milestone mode requires WIP hash evidence — without WIP, allocation cannot advance"],
+            depends_on_capabilities: ["treasury.owner_receive", "guard.validate_buy"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "allocation.distribute_milestone",
+            display_name: "Milestone-based Allocation",
+            description: "Milestone allocation: release funds by delivery milestones, each milestone requires WIP hash validation",
+            object_type: "allocation", module: "handler", category: "fund_flow",
+            industry_agnostic: "low",
+            config_template: {
+                strategy: { recipient: "entity", count: 2, mode: "milestone", description: "Milestone-based release" },
+            },
+            industry_overrides: {
+                freelance: { strategy: { recipient: "entity", count: 2, mode: "milestone", description: "50% upfront + 50% on delivery" } },
+                education: { strategy: { recipient: "entity", count: 2, mode: "milestone", description: "Per session release" } },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["allocation.distribute", "guard.validate_wip_hash"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "service.publish",
+            display_name: "Service Publish",
+            description: "Publish Service object on-chain, bind Machine/Guard/Permission/Allocation and other dependencies",
+            object_type: "service", module: "handler", category: "lifecycle",
+            industry_agnostic: "high",
+            config_template: {
+                machine: "<machine_name>",
+                buy_guard: "<guard_name>",
+                permission: "<permission_name>",
+                order_allocators: ["<allocation_name>"],
+                compensation_fund_balance: 0,
+                compensation_fund_add_hint: "Post-publish: call service.compensation_fund_add with Coin<T>. Recommend 3-10× max single-order amount (industry-specific: subscription 3×, retail 5×, rental 10×).",
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: [
+                "machine.node_topology", "guard.validate_buy", "permission.index_create",
+                "allocation.distribute", "treasury.owner_receive",
+            ],
+            version: "v1",
+        });
+        this.registerCard({
+            capability_id: "progress.advance",
+            display_name: "Progress Advance",
+            description: "Order fulfillment progress advance: advance to next state based on Machine node topology",
+            object_type: "progress", module: "handler", category: "workflow",
+            industry_agnostic: "medium",
+            config_template: { parent: "<machine_name>" },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["machine.node_topology"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "arb.vote_weighted",
+            display_name: "Arbitration Vote Weighted",
+            description: "guard-based weighted voting arbitration: vote by Guard weight to determine arbitration result",
+            object_type: "arb", module: "handler", category: "trust",
+            industry_agnostic: "medium",
+            config_template: { guard: "<guard_name>", voting_rule: "guard_weighted" },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "reward.claim_guard",
+            display_name: "Reward Claim Guard",
+            description: "Reward claim: release reward after validating claim conditions (such as positive review, repurchase) via Guard",
+            object_type: "reward", module: "handler", category: "fund_flow",
+            industry_agnostic: "medium",
+            config_template: { claim_guard: "<guard_name>", max_guard_count: 1 },
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "contact.im_create",
+            display_name: "Contact IM Create",
+            description: "Create IM contact object: buyer and seller communicate via Messenger",
+            object_type: "contact", module: "handler", category: "communication",
+            industry_agnostic: "high",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: [], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "demand.matching",
+            display_name: "Demand Matching",
+            description: "Demand matching: match corresponding Service based on user demand",
+            object_type: "demand", module: "handler", category: "query",
+            industry_agnostic: "high",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["service.publish"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "repository.write_validate",
+            display_name: "Repository Write Validate",
+            description: "Knowledge base write validation: validate write permissions and data format via Guard",
+            object_type: "repository", module: "handler", category: "validation",
+            industry_agnostic: "high",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "proof.evidence_anchor",
+            display_name: "Proof Evidence Anchor",
+            description: "Evidence on-chain: anchor delivery evidence (hash) to on-chain Progress node",
+            object_type: "proof", module: "handler", category: "evidence",
+            industry_agnostic: "medium",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["progress.advance"], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "personal.profile_manage",
+            display_name: "Personal Profile Manage",
+            description: "Personal profile management: user identity/preference/history management",
+            object_type: "personal", module: "handler", category: "data_model",
+            industry_agnostic: "high",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: [], version: "v1",
+        });
+        this.registerCard({
+            capability_id: "payment.settle",
+            display_name: "Payment Settle",
+            description: "Payment settlement: complete fund settlement in collaboration with Allocation",
+            object_type: "payment", module: "handler", category: "fund_flow",
+            industry_agnostic: "high",
+            config_template: {},
+            observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
+            depends_on_capabilities: ["allocation.distribute", "treasury.owner_receive"], version: "v1",
+        });
+    }
+    registerBuiltinEdges() {
+        const serviceDeps = [
+            "machine.node_topology", "guard.validate_buy", "permission.index_create",
+            "allocation.distribute", "treasury.owner_receive",
+        ];
+        for (const dep of serviceDeps) {
+            this.registerEdge({
+                from: "service.publish", to: dep,
+                edge_kind: "requires", phase: "publish",
+                description: "Service publish requires this capability",
+            });
+        }
+        this.registerEdge({
+            from: "service.publish", to: "arb.vote_weighted",
+            edge_kind: "optional", phase: "publish",
+            description: "Optional: arbitration for dispute resolution",
+        });
+        this.registerEdge({
+            from: "service.publish", to: "reward.claim_guard",
+            edge_kind: "optional", phase: "publish",
+            description: "Optional: reward for positive behavior",
+        });
+        this.registerEdge({
+            from: "service.publish", to: "contact.im_create",
+            edge_kind: "optional", phase: "publish",
+            description: "Optional: IM contact between buyer and seller",
+        });
+        this.registerEdge({
+            from: "permission.role_assign", to: "permission.index_create",
+            edge_kind: "requires", phase: "create",
+            description: "Role assignment requires permission index",
+        });
+        this.registerEdge({
+            from: "machine.node_topology", to: "permission.index_create",
+            edge_kind: "requires", phase: "create",
+            description: "Machine requires permission for role-based node access",
+        });
+        this.registerEdge({
+            from: "allocation.distribute", to: "treasury.owner_receive",
+            edge_kind: "requires", phase: "runtime",
+            description: "Allocation distributes via treasury",
+        });
+        this.registerEdge({
+            from: "allocation.distribute", to: "guard.validate_buy",
+            edge_kind: "requires", phase: "runtime",
+            description: "Allocation requires guard validation",
+        });
+        this.registerEdge({
+            from: "allocation.distribute_milestone", to: "allocation.distribute",
+            edge_kind: "requires", phase: "create",
+            description: "Milestone allocation extends base allocation",
+        });
+        this.registerEdge({
+            from: "allocation.distribute_milestone", to: "guard.validate_wip_hash",
+            edge_kind: "requires", phase: "runtime",
+            description: "Milestone allocation requires WIP hash validation",
+        });
+        this.registerEdge({
+            from: "progress.advance", to: "machine.node_topology",
+            edge_kind: "requires", phase: "runtime",
+            description: "Progress advances based on machine topology",
+        });
+        this.registerEdge({
+            from: "arb.vote_weighted", to: "guard.validate_buy",
+            edge_kind: "requires", phase: "runtime",
+            description: "Arbitration voting requires guard for weight validation",
+        });
+        this.registerEdge({
+            from: "reward.claim_guard", to: "guard.validate_buy",
+            edge_kind: "requires", phase: "runtime",
+            description: "Reward claim requires guard validation",
+        });
+        this.registerEdge({
+            from: "proof.evidence_anchor", to: "progress.advance",
+            edge_kind: "requires", phase: "runtime",
+            description: "Proof anchors to progress node",
+        });
+        this.registerEdge({
+            from: "payment.settle", to: "allocation.distribute",
+            edge_kind: "requires", phase: "runtime",
+            description: "Payment settles via allocation",
+        });
+        this.registerEdge({
+            from: "demand.matching", to: "service.publish",
+            edge_kind: "requires", phase: "runtime",
+            description: "Demand matching requires published services",
+        });
+        this.registerEdge({
+            from: "repository.write_validate", to: "guard.validate_buy",
+            edge_kind: "requires", phase: "runtime",
+            description: "Repository write requires guard validation",
+        });
+    }
+    computeConfigDiff(source, target) {
+        if (typeof source !== "object" || typeof target !== "object" || source === null || target === null) {
+            return source === target ? { diff_ratio: 0, summary: "identical" } : { diff_ratio: 1, summary: "type mismatch" };
+        }
+        const s = source;
+        const t = target;
+        const sKeys = new Set(Object.keys(s));
+        const tKeys = new Set(Object.keys(t));
+        const allKeys = new Set([...sKeys, ...tKeys]);
+        if (allKeys.size === 0)
+            return { diff_ratio: 0, summary: "empty configs" };
+        let diffCount = 0;
+        const diffs = [];
+        for (const k of allKeys) {
+            const sv = s[k], tv = t[k];
+            if (JSON.stringify(sv) !== JSON.stringify(tv)) {
+                diffCount++;
+                diffs.push(k);
+            }
+        }
+        const diff_ratio = diffCount / allKeys.size;
+        const summary = `${diffCount}/${allKeys.size} fields differ: ${diffs.slice(0, 3).join(", ")}${diffs.length > 3 ? "..." : ""}`;
+        return { diff_ratio, summary };
+    }
+}
+export function getCapabilityRegistry() {
+    return CapabilityRegistry.Instance();
+}
+export const CAPABILITY_MANIFEST_VERSION = 1;
+export function recordCapabilitiesUsed(industry, capabilitiesUsed) {
+    const registry = CapabilityRegistry.Instance();
+    for (const capId of capabilitiesUsed) {
+        registry.recordUsage(capId, industry);
+    }
+}

package/dist/extensions/constraint-registry.d.ts

@@ -0,0 +1,24 @@
+import type { ModeConstraint, ConstraintRule, ConstraintViolation, ConstraintSeverity, ConstraintViolationAction, IndustryMode } from "./types.js";
+import type { CapabilityRegistry } from "./capability-manifest.js";
+export declare class ConstraintRegistry {
+    private static instance;
+    private constraints;
+    private initialized;
+    static Instance(): ConstraintRegistry;
+    private constructor();
+    registerConstraint(constraint: ModeConstraint): boolean;
+    registerCustomConstraint(constraint_id: string, display_name: string, description: string, rule: ConstraintRule, owner: string, severity?: ConstraintSeverity, on_violation?: ConstraintViolationAction): boolean;
+    getConstraint(constraint_id: string): ModeConstraint | undefined;
+    listConstraints(filter?: {
+        scope?: "builtin" | "custom";
+        owner?: string;
+        severity?: ConstraintSeverity;
+    }): ModeConstraint[];
+    unregisterConstraint(constraint_id: string, owner: string): boolean;
+    checkConstraints(mode: IndustryMode, _capabilityRegistry: CapabilityRegistry, extraConstraints?: ModeConstraint[]): ConstraintViolation[];
+    private checkConstraint;
+    private getNumericField;
+    private registerBuiltinConstraints;
+}
+export declare function getConstraintRegistry(): ConstraintRegistry;
+export declare const BUILTIN_CONSTRAINTS_COUNT: number;