@wowok/agent-mcp 2.6.0 → 2.6.3

package/dist/extensions/registry.js

@@ -0,0 +1,662 @@
+import { CapabilityRegistry } from "./capability-manifest.js";
+import { ModeEvaluator } from "./mode-evaluator.js";
+import { MetricRegistry } from "./metric-registry.js";
+import { ConstraintRegistry } from "./constraint-registry.js";
+import { BUILTIN_MODES } from "./modes.js";
+export class IndustryModeRegistry {
+    static instance;
+    registrations = new Map();
+    userModes = new Map();
+    aliases = new Map();
+    evaluator;
+    initialized = false;
+    static Instance() {
+        if (!IndustryModeRegistry.instance) {
+            IndustryModeRegistry.instance = new IndustryModeRegistry();
+        }
+        return IndustryModeRegistry.instance;
+    }
+    constructor() {
+        this.evaluator = new ModeEvaluator(CapabilityRegistry.Instance(), MetricRegistry.Instance(), ConstraintRegistry.Instance());
+        this.registerBuiltinModes();
+        this.initialized = true;
+    }
+    registerMode(mode, aliases) {
+        if (!mode.name || !mode.traits || !mode.machine_shape) {
+            console.warn(`[IndustryModeRegistry] registerMode rejected: invalid mode ` +
+                `(name=${mode.name || "<missing>"}, traits=${mode.traits ? "ok" : "<missing>"}, ` +
+                `machine_shape=${mode.machine_shape ? "ok" : "<missing>"}).`);
+            return false;
+        }
+        if (this.registrations.has(mode.name)) {
+            const existing = this.registrations.get(mode.name);
+            console.warn(`[IndustryModeRegistry] registerMode rejected: mode '${mode.name}' already registered ` +
+                `(registered_at=${new Date(existing?.registered_at ?? 0).toISOString()}). ` +
+                `Use evolveMode/deriveMode for user modifications, or unregister first.`);
+            return false;
+        }
+        this.registrations.set(mode.name, {
+            mode,
+            aliases,
+            enabled: true,
+            registered_at: Date.now(),
+        });
+        if (aliases) {
+            for (const alias of aliases) {
+                this.aliases.set(alias, mode.name);
+            }
+        }
+        return true;
+    }
+    getMode(name) {
+        const canonical = this.resolveAlias(name);
+        return this.registrations.get(canonical)?.mode;
+    }
+    listModes() {
+        return Array.from(this.registrations.values())
+            .filter(r => r.enabled)
+            .map(r => r.mode);
+    }
+    resolveAlias(name) {
+        return this.aliases.get(name) ?? name;
+    }
+    hasMode(name) {
+        const canonical = this.resolveAlias(name);
+        return this.registrations.has(canonical);
+    }
+    evaluateMode(name, intent, context) {
+        const mode = this.getMode(name);
+        if (!mode) {
+            return {
+                applicable: false,
+                risk_score: 100,
+                benefit_score: 0,
+                risk_benefit_ratio: 0,
+                capability_conflicts: [],
+                violated_constraints: [],
+                unmet_conditions: [`Mode '${name}' not found`],
+                recommendations: [`Mode '${name}' not registered, falling back to 'general'`],
+            };
+        }
+        return this.evaluator.evaluateMode(mode, intent, context);
+    }
+    evaluateMigration(sourceName, targetName) {
+        const source = this.getMode(sourceName);
+        const target = this.getMode(targetName);
+        if (!source || !target) {
+            return {
+                feasibility_score: 0,
+                source_risk_score: 0,
+                target_risk_score: 0,
+                source_benefit_score: 0,
+                target_benefit_score: 0,
+                risk_delta: 0,
+                benefit_delta: 0,
+                added_capabilities: [],
+                removed_capabilities: [],
+                conflicting_capabilities: [],
+                recommendations: [`Mode '${sourceName}' or '${targetName}' not found`],
+            };
+        }
+        return this.evaluator.evaluateMigration(source, target);
+    }
+    registerUserMode(mode, userId) {
+        if (!mode.name || !mode.owner || !mode.machine_shape)
+            return false;
+        if (mode.source !== "custom")
+            return false;
+        if (mode.owner !== userId)
+            return false;
+        const userKey = this.userModeKey(mode.owner, mode.name);
+        if (this.registrations.has(mode.name))
+            return false;
+        if (this.userModes.has(userKey))
+            return false;
+        if (!mode.evolution_history || mode.evolution_history.length === 0) {
+            mode.evolution_history = [{
+                    version: mode.version || "v1",
+                    changed_at: Date.now(),
+                    changes: ["Initial registration (registerUserMode)"],
+                }];
+        }
+        this.userModes.set(userKey, mode);
+        return true;
+    }
+    deriveMode(sourceMode, modifications, userId, newName, newDisplayName) {
+        const source = this.getMode(sourceMode);
+        if (!source)
+            return undefined;
+        if (!newName || this.registrations.has(newName))
+            return undefined;
+        const userKey = this.userModeKey(userId, newName);
+        if (this.userModes.has(userKey))
+            return undefined;
+        const derived = {
+            name: newName,
+            display_name: newDisplayName ?? newName,
+            version: "v1",
+            source: "custom",
+            traits: modifications.traits ?? source.traits,
+            machine_shape: modifications.machine_shape ?? source.machine_shape,
+            guards: modifications.guards ?? source.guards,
+            allocator: modifications.allocator ?? source.allocator,
+            risk_checks: modifications.risk_checks ?? source.risk_checks,
+            needs: modifications.needs ?? source.needs,
+            flywheel: modifications.flywheel ?? source.flywheel,
+            key_risk: modifications.key_risk ?? source.key_risk,
+            build_notes: modifications.build_notes ?? source.build_notes,
+            capabilities_used: modifications.capabilities_used ?? source.capabilities_used,
+            config_overrides: modifications.config_overrides ?? source.config_overrides,
+            config_override_rules: modifications.config_override_rules ?? source.config_override_rules,
+            expected_benefits: modifications.expected_benefits ?? source.expected_benefits,
+            risk_appetite: modifications.risk_appetite ?? source.risk_appetite,
+            risk_constraints: modifications.risk_constraints ?? source.risk_constraints,
+            applicable_conditions: modifications.applicable_conditions ?? source.applicable_conditions,
+            similar_industries: modifications.similar_industries ?? source.similar_industries,
+            novel_capabilities: modifications.novel_capabilities ?? source.novel_capabilities,
+            owner: userId,
+            derived_from: sourceMode,
+            custom_metrics: modifications.custom_metrics ?? source.custom_metrics,
+            custom_constraints: modifications.custom_constraints ?? source.custom_constraints,
+            evolution_history: [{
+                    version: "v1",
+                    changed_at: Date.now(),
+                    changes: [`Derived from builtin '${sourceMode}'`],
+                }],
+        };
+        this.userModes.set(userKey, derived);
+        return derived;
+    }
+    evolveMode(modeName, updates, userId, changeDescription, bumpVersion = true) {
+        const userKey = this.userModeKey(userId, modeName);
+        const existing = this.userModes.get(userKey);
+        if (!existing)
+            return undefined;
+        const newVersion = bumpVersion
+            ? this.bumpPatchVersion(existing.version)
+            : existing.version;
+        const evolved = {
+            ...existing,
+            ...updates,
+            name: existing.name,
+            owner: existing.owner,
+            source: "custom",
+            derived_from: existing.derived_from,
+            evolution_history: [
+                ...(existing.evolution_history ?? []),
+                {
+                    version: newVersion,
+                    changed_at: Date.now(),
+                    changes: [changeDescription],
+                },
+            ],
+            version: newVersion,
+        };
+        this.userModes.set(userKey, evolved);
+        return evolved;
+    }
+    listUserModes(userId) {
+        const result = [];
+        for (const mode of this.userModes.values()) {
+            if (mode.owner === userId) {
+                result.push(mode);
+            }
+        }
+        return result;
+    }
+    getUserMode(modeName, userId) {
+        const userKey = this.userModeKey(userId, modeName);
+        return this.userModes.get(userKey);
+    }
+    unregisterUserMode(modeName, userId) {
+        const userKey = this.userModeKey(userId, modeName);
+        return this.userModes.delete(userKey);
+    }
+    userModeKey(owner, name) {
+        return `${owner}:${name}`;
+    }
+    bumpPatchVersion(version) {
+        const parts = version.replace(/^v/, "").split(".");
+        if (parts.length < 2)
+            return `v${version}.1`;
+        const patch = parseInt(parts[1] ?? "0", 10);
+        parts[1] = String(patch + 1);
+        return `v${parts.join(".")}`;
+    }
+    applyTemplate(name, intent, context) {
+        const builtinMode = this.getMode(name);
+        if (builtinMode) {
+            const blueprint = this.doApplyTemplate(builtinMode, intent, context);
+            this.recordCapabilitiesUsed(builtinMode);
+            return blueprint;
+        }
+        if (name.includes(":")) {
+            const [owner, modeName] = name.split(":", 2);
+            const userMode = this.getUserMode(modeName, owner);
+            if (userMode) {
+                const blueprint = this.doApplyTemplate(userMode, intent, context);
+                this.recordCapabilitiesUsed(userMode);
+                return blueprint;
+            }
+        }
+        const general = this.getMode("general");
+        if (!general) {
+            throw new Error("IndustryMode 'general' not registered — cannot fallback");
+        }
+        const blueprint = this.doApplyTemplate(general, intent, context);
+        this.recordCapabilitiesUsed(general);
+        return blueprint;
+    }
+    applyUserMode(modeName, userId, intent, context) {
+        const userMode = this.getUserMode(modeName, userId);
+        if (!userMode) {
+            throw new Error(`User mode '${modeName}' not found for user '${userId}'`);
+        }
+        const blueprint = this.doApplyTemplate(userMode, intent, context);
+        this.recordCapabilitiesUsed(userMode);
+        return blueprint;
+    }
+    doApplyTemplate(mode, intent, context) {
+        let objects = this.buildObjects(mode, intent, context);
+        objects = this.applyConfigOverrides(mode, objects);
+        objects = this.applyConfigOverrideRules(mode, objects, intent, context);
+        const edges = this.buildEdges(objects, context);
+        const steps = this.buildSteps(objects, edges, context.network);
+        const scenarios = this.defaultScenarios(mode, intent, objects);
+        const validation = this.validateBlueprint(objects, edges, mode);
+        if (validation.errors.length > 0) {
+            throw new Error(`Blueprint validation for mode '${mode.name}' failed with ${validation.errors.length} CRITICAL error(s):\n` +
+                validation.errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n"));
+        }
+        if (validation.warnings.length > 0) {
+            console.warn(`[IndustryModeRegistry] Blueprint validation for '${mode.name}' produced ${validation.warnings.length} warning(s):`, validation.warnings);
+        }
+        return {
+            context,
+            objects,
+            edges,
+            steps,
+            scenarios,
+            industry_source: mode.name,
+            applied_template: `${mode.name}@${mode.version}`,
+            validation,
+        };
+    }
+    validateBlueprint(objects, edges, mode) {
+        const errors = [];
+        const warnings = [];
+        const machine = objects.find(o => o.object_type === "machine");
+        const service = objects.find(o => o.object_type === "service");
+        if (machine) {
+            const hint = machine.config.entry_node_forward_hint;
+            if (!hint) {
+                warnings.push("Machine blueprint missing entry_node_forward_hint. " +
+                    "The AI must ensure the entry node (prev_node='') has ≥1 forward when constructing the Machine creation call (P0-2).");
+            }
+            else if (hint.required === true && !hint.example_forward) {
+                warnings.push("Machine entry_node_forward_hint marked required but example_forward is missing.");
+            }
+            const nodes = machine.config.nodes;
+            if (!nodes || nodes.length === 0) {
+                errors.push(`Machine blueprint has no nodes — mode '${mode.name}' machine_shape is empty. ` +
+                    `Add nodes to the mode's machine_shape before applying template.`);
+            }
+        }
+        if (service) {
+            const compensationFundRef = service.config.compensation_fund;
+            if (compensationFundRef) {
+                errors.push(`Service blueprint has compensation_fund='${compensationFundRef}' (string reference). ` +
+                    `BUG: compensation_fund is Balance<T> (numeric), NOT a Treasury object reference. ` +
+                    `Remove compensation_fund field and use compensation_fund_balance + compensation_fund_add_hint instead. ` +
+                    `Smart contract (service.move:179): compensation_fund: Balance<T>.`);
+            }
+            const balanceField = service.config.compensation_fund_balance;
+            if (balanceField === undefined) {
+                warnings.push("Service blueprint missing compensation_fund_balance. " +
+                    "Should be 0 (initial Balance<T> state) — filled via service.compensation_fund_add(coin).");
+            }
+        }
+        const objectIds = new Set(objects.map(o => o.entry_id));
+        const objectNames = new Set(objects.map(o => o.name));
+        for (const edge of edges) {
+            const fromOk = objectIds.has(edge.from) || objectNames.has(edge.from);
+            const toOk = objectIds.has(edge.to) || objectNames.has(edge.to);
+            if (!fromOk || !toOk) {
+                errors.push(`Edge '${edge.from}' → '${edge.to}' (kind='${edge.edge_kind}') references undefined object. ` +
+                    `from_exists=${fromOk}, to_exists=${toOk}.`);
+            }
+        }
+        return { errors, warnings };
+    }
+    buildObjects(mode, intent, context) {
+        const prefix = context.prefix;
+        const objects = [];
+        objects.push(this.makeObject("permission", `${prefix}_permission`, {
+            name: `${prefix}_permission`,
+            description: `Permission: role permission index (${mode.display_name})`,
+            permission_indexes: this.buildPermissionIndexes(mode),
+            tags: [`industry:${mode.name}`],
+        }));
+        const serviceGuardName = this.getFirstServiceGuardName(mode, prefix);
+        for (const guard of mode.guards) {
+            const shortName = this.deriveGuardShortName(guard.template_id);
+            const guardName = `${prefix}_guard_${shortName}`;
+            objects.push(this.makeObject("guard", guardName, {
+                name: guardName,
+                description: `Guard: ${guard.purpose} (${mode.display_name})`,
+                host: guard.host,
+                template_id: guard.template_id,
+                tags: [`industry:${mode.name}`, `host:${guard.host}`],
+            }));
+        }
+        objects.push(this.makeObject("machine", `${prefix}_machine`, {
+            name: `${prefix}_machine`,
+            description: `Machine: workflow topology (${mode.display_name}) — ${mode.machine_shape.length} nodes`,
+            nodes: mode.machine_shape.map(n => ({ name: n.name, role: n.role })),
+            guard_objects: mode.guards
+                .filter(g => g.host === "machine")
+                .map(g => ({
+                template_id: g.template_id,
+                object_name: `${prefix}_guard_${this.deriveGuardShortName(g.template_id)}`,
+                purpose: g.purpose,
+            })),
+            permission: `${prefix}_permission`,
+            entry_node_forward_hint: {
+                entry_node_name: mode.machine_shape[0]?.name ?? "paid",
+                required: true,
+                example_forward: {
+                    next_node: mode.machine_shape[0]?.name ?? "paid",
+                    namedOperator: "",
+                    weight: 1,
+                },
+                reason: "Progress starts at current='' and follows the entry node's forwards. " +
+                    "Without a forward, Progress is permanently stuck (P0-2). " +
+                    "Schema refinement in MachineNodePairSchema enforces this at publish time.",
+            },
+            tags: [`industry:${mode.name}`],
+        }, true));
+        objects.push(this.makeObject("treasury", `${prefix}_treasury`, {
+            name: `${prefix}_treasury`,
+            description: `Treasury: fund escrow (${mode.display_name})`,
+            owner_receive: true,
+            tags: [`industry:${mode.name}`],
+        }));
+        objects.push(this.makeObject("allocation", `${prefix}_allocation`, {
+            name: `${prefix}_allocation`,
+            description: `Allocation: allocation strategy (${mode.display_name}) — ${mode.allocator.description}`,
+            strategy: mode.allocator,
+            treasury: `${prefix}_treasury`,
+            guard: serviceGuardName,
+            tags: [`industry:${mode.name}`],
+        }));
+        objects.push(this.makeObject("service", `${prefix}_service`, {
+            name: `${prefix}_service`,
+            description: `Service: business service (${mode.display_name}) — ${intent.slice(0, 100)}`,
+            machine: `${prefix}_machine`,
+            buy_guard: serviceGuardName,
+            permission: `${prefix}_permission`,
+            order_allocators: [`${prefix}_allocation`],
+            compensation_fund_balance: 0,
+            compensation_fund_required: mode.risk_constraints?.require_compensation_fund ?? false,
+            compensation_fund_coverage_ratio: mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5,
+            compensation_fund_add_hint: "Call service.compensation_fund_add with a Coin<T> to deposit. " +
+                "The compensation_fund is a Balance<T> (numeric), not a Treasury object reference. " +
+                "Without deposit, arbitration rulings that award refunds to buyers cannot be paid out. " +
+                `Recommend ${mode.risk_constraints?.compensation_fund_coverage_ratio ?? 5}× the max single-order amount (P1-1 evaluation rule, industry: ${mode.name}).`,
+            arbitrations: [`${prefix}_arb`],
+            rewards: [`${prefix}_reward`],
+            business_intent: intent,
+            industry: mode.name,
+            tags: [`industry:${mode.name}`],
+        }, true));
+        objects.push(this.makeObject("progress", `${prefix}_progress`, {
+            name: `${prefix}_progress`,
+            description: `Progress: order fulfillment progress (${mode.display_name})`,
+            parent: `${prefix}_machine`,
+            tags: [`industry:${mode.name}`],
+        }));
+        objects.push(this.makeObject("arb", `${prefix}_arb`, {
+            name: `${prefix}_arb`,
+            description: `Arbitration: arbitration rules (${mode.display_name}) — ${mode.key_risk}`,
+            guard: `${prefix}_guard_buy`,
+            tags: [`industry:${mode.name}`],
+        }));
+        objects.push(this.makeObject("reward", `${prefix}_reward`, {
+            name: `${prefix}_reward`,
+            description: `Reward: incentive rules (${mode.display_name})`,
+            claim_guard: `${prefix}_guard_buy`,
+            tags: [`industry:${mode.name}`],
+        }));
+        objects.push(this.makeObject("contact", `${prefix}_contact`, {
+            name: `${prefix}_contact`,
+            description: `Contact: customer service contact (${mode.display_name})`,
+            tags: [`industry:${mode.name}`],
+        }));
+        return objects;
+    }
+    buildPermissionIndexes(mode) {
+        const permOverrides = mode.config_overrides?.["permission"];
+        if (permOverrides?.permission_indexes) {
+            return permOverrides.permission_indexes;
+        }
+        return [
+            { name: "merchant", description: "Service owner / provider" },
+            { name: "customer", description: "Service buyer / customer" },
+            { name: "arbiter", description: "Arbitration arbiter" },
+        ];
+    }
+    applyConfigOverrides(mode, objects) {
+        if (!mode.config_overrides)
+            return objects;
+        for (const obj of objects) {
+            const overrides = mode.config_overrides[obj.object_type];
+            if (overrides) {
+                for (const [key, value] of Object.entries(overrides)) {
+                    obj.config[key] = value;
+                }
+            }
+        }
+        return objects;
+    }
+    applyConfigOverrideRules(mode, objects, intent, context) {
+        if (!mode.config_override_rules)
+            return objects;
+        for (const rule of mode.config_override_rules) {
+            const obj = objects.find(o => o.object_type === rule.object_type);
+            if (!obj)
+                continue;
+            let valueToApply;
+            if (rule.condition) {
+                const matched = this.evaluateCondition(rule, intent, context);
+                valueToApply = matched ? rule.condition.then_value : (rule.condition.else_value ?? rule.value);
+            }
+            else {
+                valueToApply = rule.value;
+            }
+            if (valueToApply !== undefined) {
+                this.setNestedField(obj.config, rule.field_path, valueToApply);
+            }
+        }
+        return objects;
+    }
+    evaluateCondition(rule, intent, context) {
+        if (!rule.condition)
+            return false;
+        if (rule.condition.intent_contains) {
+            return intent.toLowerCase().includes(rule.condition.intent_contains.toLowerCase());
+        }
+        if (rule.condition.context_field && rule.condition.matches !== undefined) {
+            const fieldValue = context[rule.condition.context_field];
+            return fieldValue === rule.condition.matches;
+        }
+        return false;
+    }
+    setNestedField(obj, path, value) {
+        const parts = path.split(".");
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (current[part] === undefined || current[part] === null) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+    buildEdges(objects, context) {
+        const edges = [];
+        const find = (name) => objects.find(o => o.name === name);
+        const configPrefix = objects[0]?.config?.prefix;
+        const prefix = context?.prefix
+            ?? (typeof configPrefix === "string" ? configPrefix : undefined)
+            ?? objects[0]?.name.split("_")[0]
+            ?? "";
+        const service = find(`${prefix}_service`);
+        const machine = find(`${prefix}_machine`);
+        const permission = find(`${prefix}_permission`);
+        const allocation = find(`${prefix}_allocation`);
+        const treasury = find(`${prefix}_treasury`);
+        const arb = find(`${prefix}_arb`);
+        const reward = find(`${prefix}_reward`);
+        const progress = find(`${prefix}_progress`);
+        const allGuards = objects.filter(o => o.object_type === "guard");
+        const serviceGuard = allGuards.find(g => g.config?.host === "service");
+        const machineGuards = allGuards.filter(g => g.config?.host === "machine");
+        if (!service || !machine || !permission) {
+            const missing = [];
+            if (!service)
+                missing.push("service");
+            if (!machine)
+                missing.push("machine");
+            if (!permission)
+                missing.push("permission");
+            console.warn(`[buildEdges] Missing core objects: ${missing.join(", ")}. ` +
+                `Edges will be empty (prefix='${prefix}'). ` +
+                `Check buildObjects output or context.prefix.`);
+            return edges;
+        }
+        edges.push(this.makeEdge(service, machine, "machine", "service.machine", true));
+        if (serviceGuard) {
+            edges.push(this.makeEdge(service, serviceGuard, "buy_guard", "service.buy_guard", true));
+        }
+        edges.push(this.makeEdge(service, permission, "permission", "service.permission", true));
+        if (allocation)
+            edges.push(this.makeEdge(service, allocation, "order_allocators", "service.order_allocators", true));
+        if (arb)
+            edges.push(this.makeEdge(service, arb, "arbitrations", "service.arbitrations", false));
+        if (reward)
+            edges.push(this.makeEdge(service, reward, "rewards", "service.rewards", false));
+        edges.push(this.makeEdge(machine, permission, "permission", "machine.permission", false));
+        for (const mg of machineGuards) {
+            edges.push(this.makeEdge(machine, mg, "guard", "machine.forwards.guard", false));
+        }
+        if (progress)
+            edges.push(this.makeEdge(progress, machine, "parent", "progress.parent", false));
+        if (allocation && treasury)
+            edges.push(this.makeEdge(allocation, treasury, "treasury", "allocation.treasury", false));
+        if (allocation && serviceGuard)
+            edges.push(this.makeEdge(allocation, serviceGuard, "buy_guard", "allocation.guard", false));
+        return edges;
+    }
+    makeEdge(from, to, edge_kind, field_path, required_at_publish) {
+        return {
+            from: from.entry_id,
+            to: to.entry_id,
+            edge_kind,
+            field_path,
+            required_at_publish,
+        };
+    }
+    buildSteps(objects, edges, network) {
+        const order = [
+            "permission", "guard", "machine", "treasury", "allocation",
+            "arb", "reward", "contact", "service", "progress",
+        ];
+        const steps = [];
+        const entryToStep = new Map();
+        let stepNum = 1;
+        for (const type of order) {
+            const obj = objects.find(o => o.object_type === type);
+            if (!obj)
+                continue;
+            const depends = [];
+            for (const edge of edges) {
+                if (edge.to === obj.entry_id) {
+                    const depStep = entryToStep.get(edge.from);
+                    if (depStep !== undefined) {
+                        depends.push(depStep);
+                    }
+                }
+            }
+            const operation = obj.publish_required ? "publish" : "create";
+            steps.push({
+                step: stepNum,
+                object_type: obj.object_type,
+                operation,
+                substep_count: 1,
+                depends_on: depends,
+                entry_id: obj.entry_id,
+                network_phase: network,
+            });
+            entryToStep.set(obj.entry_id, stepNum);
+            stepNum++;
+        }
+        return steps;
+    }
+    defaultScenarios(mode, intent, objects) {
+        const service = objects.find(o => o.object_type === "service");
+        return [{
+                scenario_id: `${mode.name}_primary`,
+                description: `${mode.display_name} main flow: ${intent.slice(0, 80)}`,
+                primary_object: service?.entry_id ?? "",
+                supporting_objects: objects.filter(o => o.object_type !== "service").map(o => o.entry_id),
+            }];
+    }
+    recordCapabilitiesUsed(mode) {
+        if (!mode.capabilities_used)
+            return;
+        try {
+            const registry = CapabilityRegistry.Instance();
+            for (const capId of mode.capabilities_used) {
+                registry.recordUsage(capId, mode.name);
+            }
+        }
+        catch {
+        }
+    }
+    deriveGuardShortName(templateId) {
+        if (templateId.startsWith("tpl_")) {
+            const parts = templateId.split("_");
+            return parts[parts.length - 1] || templateId;
+        }
+        const match = templateId.match(/^([a-z]+)_guard_/);
+        if (match)
+            return match[1];
+        return templateId.split("_")[0] || templateId;
+    }
+    getFirstServiceGuardName(mode, prefix) {
+        const serviceGuard = mode.guards.find(g => g.host === "service");
+        if (!serviceGuard)
+            return "";
+        return `${prefix}_guard_${this.deriveGuardShortName(serviceGuard.template_id)}`;
+    }
+    makeObject(type, name, config, publish_required = false) {
+        return {
+            entry_id: `${type}:${name}`,
+            object_type: type,
+            name,
+            config,
+            publish_required,
+            status: "draft",
+        };
+    }
+    registerBuiltinModes() {
+        for (const mode of BUILTIN_MODES) {
+            this.registerMode(mode);
+        }
+    }
+}
+export function getIndustryModeRegistry() {
+    return IndustryModeRegistry.Instance();
+}
+export const INDUSTRY_MODE_REGISTRY_VERSION = 2.1;