@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/extensions/capability-manifest.js

@@ -229,6 +229,14 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Index proliferation without naming convention makes permission audits harder"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Role-based governance foundation for all other objects"],
+            },
         });
         this.registerCard({
             capability_id: "permission.role_assign",
@@ -239,6 +247,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Mis-assigned role grants unintended operational authority"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Binds governance roles to concrete objects"],
+            },
         });
         this.registerCard({
             capability_id: "guard.validate_buy",
@@ -254,6 +270,14 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["permission.index_create"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Over-strict buy validation blocks legitimate orders; over-loose validation admits fraud"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Automated purchase gating without manual review"],
+            },
         });
         this.registerCard({
             capability_id: "guard.validate_wip_hash",
@@ -268,6 +292,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Wrong hash algorithm or field mapping stalls milestone release"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Tamper-proof delivery evidence for digital deliverables"],
+            },
         });
         this.registerCard({
             capability_id: "machine.node_topology",
@@ -279,9 +311,9 @@ export class CapabilityRegistry {
                 nodes: [
                     { name: "paid", role: "Entry: order created and paid" },
                     { name: "delivering", role: "Service delivery in progress" },
+                    { name: "delivered", role: "Deliverable available for review" },
                     { name: "completed", role: "Service completed, funds released" },
-                    { name: "refunded", role: "Customer refund path" },
-                    { name: "cancelled", role: "Pre-delivery cancellation" },
+                    { name: "cancelled", role: "Pre-delivery cancellation — triggers refund Allocator" },
                 ],
             },
             industry_overrides: {
@@ -291,7 +323,7 @@ export class CapabilityRegistry {
                         { name: "delivered", role: "Goods delivered" },
                         { name: "confirmed", role: "Buyer confirms receipt" },
                         { name: "completed", role: "Funds released" },
-                        { name: "refunded", role: "Return & refund" },
+                        { name: "returned", role: "Buyer ships goods back — triggers refund Allocator (R-M1-11)" },
                         { name: "cancelled", role: "Pre-ship cancellation" },
                     ] },
                 freelance: { nodes: [
@@ -301,12 +333,19 @@ export class CapabilityRegistry {
                         { 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" },
+                        { name: "cancelled", role: "Pre-start cancellation — triggers refund Allocator (R-M1-11)" },
                     ] },
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["permission.index_create"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Dead-end nodes or missing refund paths trap order funds"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Declarative workflow from order creation to completion"],
+            },
         });
         this.registerCard({
             capability_id: "treasury.owner_receive",
@@ -317,6 +356,14 @@ export class CapabilityRegistry {
             config_template: { owner_receive: true },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Direct fund custody — misconfigured owner diverts all proceeds"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Automated escrow and owner settlement"],
+            },
         });
         this.registerCard({
             capability_id: "allocation.distribute",
@@ -335,6 +382,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "low", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Wrong split ratios or recipient addresses misdirect settlement funds"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Multi-recipient settlement without manual transfers"],
+            },
         });
         this.registerCard({
             capability_id: "allocation.distribute_milestone",
@@ -351,6 +406,14 @@ export class CapabilityRegistry {
             },
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["allocation.distribute", "guard.validate_wip_hash"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Stuck milestone gates lock buyer funds until evidence is supplied"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Evidence-gated release protects both buyer and provider"],
+            },
         });
         this.registerCard({
             capability_id: "service.publish",
@@ -372,6 +435,14 @@ export class CapabilityRegistry {
                 "allocation.distribute", "treasury.owner_receive",
             ],
             version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "medium",
+                known_risks: ["Publish freezes machine binding and order_allocators permanently (E_ALREADY_PUBLISHED)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["On-chain discoverability and order intake"],
+            },
         });
         this.registerCard({
             capability_id: "progress.advance",
@@ -382,6 +453,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "low", delivery_risk: "high", compliance_risk: "low",
+                known_risks: ["Forward without authorized executor permanently stalls the order"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "high",
+                benefits: ["Deterministic order state progression"],
+            },
         });
         this.registerCard({
             capability_id: "arb.vote_weighted",
@@ -392,6 +471,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "high", delivery_risk: "medium", compliance_risk: "medium",
+                known_risks: ["Shared permission with Service destroys dispute independence (E_ARBITRATION_PERMISSION_CONFLICT)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "low",
+                benefits: ["Neutral third-party dispute resolution"],
+            },
         });
         this.registerCard({
             capability_id: "reward.claim_guard",
@@ -402,6 +489,14 @@ export class CapabilityRegistry {
             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",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Loose claim conditions drain the reward pool"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Incentivizes reviews and repurchase"],
+            },
         });
         this.registerCard({
             capability_id: "contact.im_create",
@@ -412,6 +507,14 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Unattended IM channel degrades dispute response time"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "medium", efficiency_gain: "medium",
+                benefits: ["Direct buyer-seller encrypted communication"],
+            },
         });
         this.registerCard({
             capability_id: "demand.matching",
@@ -422,6 +525,14 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["service.publish"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Poor matching signals bury quality services"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "low", efficiency_gain: "medium",
+                benefits: ["Demand-side discovery channel"],
+            },
         });
         this.registerCard({
             capability_id: "repository.write_validate",
@@ -432,6 +543,14 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Unvalidated writes pollute the knowledge base with unverifiable claims"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Guard-gated attestation for off-chain data"],
+            },
         });
         this.registerCard({
             capability_id: "proof.evidence_anchor",
@@ -442,6 +561,14 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["progress.advance"], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "medium", delivery_risk: "low", compliance_risk: "low",
+                known_risks: ["Anchored evidence is immutable — wrong hash cannot be corrected"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "medium",
+                benefits: ["Immutable WTS evidence for Messenger confirmations"],
+            },
         });
         this.registerCard({
             capability_id: "personal.profile_manage",
@@ -452,6 +579,14 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: [], version: "v1",
+            risk_profile: {
+                funds_risk: "low", trust_risk: "low", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Profile data may fall under privacy regulation (PII)"],
+            },
+            benefit_profile: {
+                automation_level: "medium", trust_boost: "low", efficiency_gain: "low",
+                benefits: ["Portable user identity across services"],
+            },
         });
         this.registerCard({
             capability_id: "payment.settle",
@@ -462,6 +597,58 @@ export class CapabilityRegistry {
             config_template: {},
             observed_in_industries: {}, success_count: 0, failure_count: 0, known_failure_modes: [],
             depends_on_capabilities: ["allocation.distribute", "treasury.owner_receive"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "low", delivery_risk: "low", compliance_risk: "medium",
+                known_risks: ["Settlement errors are irreversible once funds transfer"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "low", efficiency_gain: "high",
+                benefits: ["Atomic settlement in collaboration with Allocation"],
+            },
+        });
+        this.registerCard({
+            capability_id: "guard.validate_withdraw",
+            display_name: "Guard Validate Withdraw",
+            description: "Withdrawal validation: gate fund release from Allocation escrow on delivery confirmation",
+            object_type: "guard", module: "handler", category: "validation",
+            industry_agnostic: "medium",
+            config_template: { host: "service", templates: ["tpl_withdraw_on_completed"] },
+            industry_overrides: {
+                retail_d2c: { templates: ["tpl_withdraw_on_completed"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["Withdraw gate on wrong node lets merchant pull funds before delivery"],
+            depends_on_capabilities: ["allocation.distribute"], version: "v1",
+            risk_profile: {
+                funds_risk: "high", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Mis-gated withdrawal releases escrowed funds prematurely"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Contract-enforced delivery gate replaces platform custody"],
+            },
+        });
+        this.registerCard({
+            capability_id: "guard.validate_refund",
+            display_name: "Guard Validate Refund",
+            description: "Refund validation: gate buyer refund on cancellation or return conditions",
+            object_type: "guard", module: "handler", category: "validation",
+            industry_agnostic: "medium",
+            config_template: { host: "service", templates: ["tpl_refund_on_cancelled"] },
+            industry_overrides: {
+                retail_d2c: { templates: ["tpl_refund_on_cancelled"] },
+            },
+            observed_in_industries: {}, success_count: 0, failure_count: 0,
+            known_failure_modes: ["Missing refund path on pre-delivery cancellation traps buyer funds"],
+            depends_on_capabilities: ["guard.validate_buy"], version: "v1",
+            risk_profile: {
+                funds_risk: "medium", trust_risk: "medium", delivery_risk: "medium", compliance_risk: "low",
+                known_risks: ["Over-broad refund conditions enable buyer abuse"],
+            },
+            benefit_profile: {
+                automation_level: "high", trust_boost: "high", efficiency_gain: "high",
+                benefits: ["Trustless buyer refund without merchant approval"],
+            },
         });
     }
     registerBuiltinEdges() {

package/dist/extensions/constraint-registry.js

@@ -92,7 +92,9 @@ export class ConstraintRegistry {
         return this.constraints.delete(constraint_id);
     }
     checkConstraints(mode, _capabilityRegistry, extraConstraints) {
-        const allConstraints = [...this.constraints.values()];
+        const disabled = new Set(mode.disabled_builtin_constraints ?? []);
+        const allConstraints = [...this.constraints.values()]
+            .filter(c => !(c.scope === "builtin" && disabled.has(c.constraint_id)));
         if (extraConstraints) {
             for (const c of extraConstraints) {
                 if (!allConstraints.some(existing => existing.constraint_id === c.constraint_id)) {

package/dist/extensions/modes.js

@@ -25,9 +25,9 @@ const GENERAL_FLYWHEEL = {
 const GENERAL_MACHINE_SHAPE = [
     { name: "paid", role: "Entry: order created and paid" },
     { name: "delivering", role: "Service delivery in progress" },
+    { name: "delivered", role: "Deliverable available for review" },
     { name: "completed", role: "Service completed, funds released" },
-    { name: "refunded", role: "Customer refund path" },
-    { name: "cancelled", role: "Pre-delivery cancellation" },
+    { name: "cancelled", role: "Pre-delivery cancellation — triggers refund Allocator" },
 ];
 const GENERAL_ALLOCATOR = {
     recipient: "signer",
@@ -41,8 +41,8 @@ const RETAIL_MACHINE_SHAPE = [
     { name: "delivered", role: "Goods delivered to buyer" },
     { name: "confirmed", role: "Buyer confirms receipt" },
     { name: "completed", role: "Funds released to merchant" },
-    { name: "refunded", role: "Return & refund path" },
-    { name: "cancelled", role: "Pre-ship cancellation" },
+    { name: "returned", role: "Buyer ships goods back — triggers refund Allocator (R-M1-11 compliant)" },
+    { name: "cancelled", role: "Pre-ship cancellation — triggers refund Allocator" },
 ];
 const RETAIL_GUARDS = [
     { template_id: "buy_guard_inventory", host: "service", purpose: "Verify inventory and buyer address on purchase" },
@@ -187,6 +187,7 @@ export const BUILTIN_MODES = [
         },
         similar_industries: ["rental", "education"],
         novel_capabilities: ["allocation.distribute_milestone"],
+        disabled_builtin_constraints: ["require_compensation_fund"],
     },
     {
         name: "rental",
@@ -275,6 +276,7 @@ export const BUILTIN_MODES = [
         },
         similar_industries: ["freelance", "subscription"],
         novel_capabilities: ["allocation.distribute_milestone"],
+        disabled_builtin_constraints: ["require_wip_evidence"],
     },
     {
         name: "travel",
@@ -368,6 +370,7 @@ export const BUILTIN_MODES = [
         },
         similar_industries: ["freelance", "education"],
         novel_capabilities: [],
+        disabled_builtin_constraints: ["require_arbitration", "require_compensation_fund", "require_wip_evidence"],
     },
     {
         name: "retail",
@@ -413,6 +416,7 @@ export const BUILTIN_MODES = [
         },
         similar_industries: ["rental", "subscription"],
         novel_capabilities: [],
+        disabled_builtin_constraints: ["require_wip_evidence"],
     },
     {
         name: "retail_d2c",
@@ -458,6 +462,7 @@ export const BUILTIN_MODES = [
         },
         similar_industries: ["retail", "subscription"],
         novel_capabilities: ["Allocation escrow as platform-custody alternative", "Multi-recipient allocation (merchant + processor)"],
+        disabled_builtin_constraints: ["require_arbitration", "require_compensation_fund", "require_wip_evidence"],
     },
     {
         name: "general",
@@ -489,5 +494,6 @@ export const BUILTIN_MODES = [
         },
         similar_industries: [],
         novel_capabilities: [],
+        disabled_builtin_constraints: ["require_arbitration", "require_compensation_fund", "require_wip_evidence"],
     },
 ];

package/dist/extensions/registry.d.ts

@@ -6,6 +6,8 @@ export declare class IndustryModeRegistry {
     private aliases;
     private evaluator;
     private initialized;
+    private persistence;
+    private userModesLoaded;
     static Instance(): IndustryModeRegistry;
     private constructor();
     registerMode(mode: IndustryMode, aliases?: string[]): boolean;
@@ -15,16 +17,19 @@ export declare class IndustryModeRegistry {
     hasMode(name: string): boolean;
     evaluateMode(name: string, intent: string, context: ProjectContext): ModeEvaluation;
     evaluateMigration(sourceName: string, targetName: string): ModeMigrationEvaluation;
-    registerUserMode(mode: UserDefinedMode, userId: string): boolean;
-    deriveMode(sourceMode: string, modifications: Partial<UserDefinedMode>, userId: string, newName: string, newDisplayName?: string): UserDefinedMode | undefined;
-    evolveMode(modeName: string, updates: Partial<UserDefinedMode>, userId: string, changeDescription: string, bumpVersion?: boolean): UserDefinedMode | undefined;
-    listUserModes(userId: string): UserDefinedMode[];
-    getUserMode(modeName: string, userId: string): UserDefinedMode | undefined;
-    unregisterUserMode(modeName: string, userId: string): boolean;
+    registerUserMode(mode: UserDefinedMode, userId: string): Promise<boolean>;
+    deriveMode(sourceMode: string, modifications: Partial<UserDefinedMode>, userId: string, newName: string, newDisplayName?: string): Promise<UserDefinedMode | undefined>;
+    evolveMode(modeName: string, updates: Partial<UserDefinedMode>, userId: string, changeDescription: string, bumpVersion?: boolean): Promise<UserDefinedMode | undefined>;
+    listUserModes(userId: string): Promise<UserDefinedMode[]>;
+    getUserMode(modeName: string, userId: string): Promise<UserDefinedMode | undefined>;
+    unregisterUserMode(modeName: string, userId: string): Promise<boolean>;
     private userModeKey;
+    private ensureUserModesLoaded;
+    private persistUserMode;
+    private unpersistUserMode;
     private bumpPatchVersion;
-    applyTemplate(name: string, intent: string, context: ProjectContext): Blueprint;
-    applyUserMode(modeName: string, userId: string, intent: string, context: ProjectContext): Blueprint;
+    applyTemplate(name: string, intent: string, context: ProjectContext): Promise<Blueprint>;
+    applyUserMode(modeName: string, userId: string, intent: string, context: ProjectContext): Promise<Blueprint>;
     private doApplyTemplate;
     validateBlueprint(objects: BlueprintObject[], edges: BlueprintEdge[], mode: IndustryMode): {
         errors: string[];
@@ -47,4 +52,4 @@ export declare class IndustryModeRegistry {
     private registerBuiltinModes;
 }
 export declare function getIndustryModeRegistry(): IndustryModeRegistry;
-export declare const INDUSTRY_MODE_REGISTRY_VERSION = 2.1;
+export declare const INDUSTRY_MODE_REGISTRY_VERSION = 2.2;

package/dist/extensions/registry.js

@@ -1,3 +1,4 @@
+import { UserModeStorage } from "@wowok/wowok";
 import { CapabilityRegistry } from "./capability-manifest.js";
 import { ModeEvaluator } from "./mode-evaluator.js";
 import { MetricRegistry } from "./metric-registry.js";
@@ -10,6 +11,8 @@ export class IndustryModeRegistry {
     aliases = new Map();
     evaluator;
     initialized = false;
+    persistence = new UserModeStorage();
+    userModesLoaded = false;
     static Instance() {
         if (!IndustryModeRegistry.instance) {
             IndustryModeRegistry.instance = new IndustryModeRegistry();
@@ -100,7 +103,8 @@ export class IndustryModeRegistry {
         }
         return this.evaluator.evaluateMigration(source, target);
     }
-    registerUserMode(mode, userId) {
+    async registerUserMode(mode, userId) {
+        await this.ensureUserModesLoaded();
         if (!mode.name || !mode.owner || !mode.machine_shape)
             return false;
         if (mode.source !== "custom")
@@ -120,9 +124,11 @@ export class IndustryModeRegistry {
                 }];
         }
         this.userModes.set(userKey, mode);
+        await this.persistUserMode(mode);
         return true;
     }
-    deriveMode(sourceMode, modifications, userId, newName, newDisplayName) {
+    async deriveMode(sourceMode, modifications, userId, newName, newDisplayName) {
+        await this.ensureUserModesLoaded();
         const source = this.getMode(sourceMode);
         if (!source)
             return undefined;
@@ -165,9 +171,11 @@ export class IndustryModeRegistry {
                 }],
         };
         this.userModes.set(userKey, derived);
+        await this.persistUserMode(derived);
         return derived;
     }
-    evolveMode(modeName, updates, userId, changeDescription, bumpVersion = true) {
+    async evolveMode(modeName, updates, userId, changeDescription, bumpVersion = true) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
         const existing = this.userModes.get(userKey);
         if (!existing)
@@ -193,9 +201,11 @@ export class IndustryModeRegistry {
             version: newVersion,
         };
         this.userModes.set(userKey, evolved);
+        await this.persistUserMode(evolved);
         return evolved;
     }
-    listUserModes(userId) {
+    async listUserModes(userId) {
+        await this.ensureUserModesLoaded();
         const result = [];
         for (const mode of this.userModes.values()) {
             if (mode.owner === userId) {
@@ -204,26 +214,71 @@ export class IndustryModeRegistry {
         }
         return result;
     }
-    getUserMode(modeName, userId) {
+    async getUserMode(modeName, userId) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
         return this.userModes.get(userKey);
     }
-    unregisterUserMode(modeName, userId) {
+    async unregisterUserMode(modeName, userId) {
+        await this.ensureUserModesLoaded();
         const userKey = this.userModeKey(userId, modeName);
-        return this.userModes.delete(userKey);
+        const removed = this.userModes.delete(userKey);
+        if (removed) {
+            await this.unpersistUserMode(userId, modeName);
+        }
+        return removed;
     }
     userModeKey(owner, name) {
         return `${owner}:${name}`;
     }
+    async ensureUserModesLoaded() {
+        if (this.userModesLoaded)
+            return;
+        this.userModesLoaded = true;
+        try {
+            const rows = await this.persistence.list();
+            for (const row of rows) {
+                try {
+                    const mode = JSON.parse(row.data);
+                    if (mode?.name && mode?.owner && mode?.machine_shape) {
+                        this.userModes.set(this.userModeKey(row.owner, row.name), mode);
+                    }
+                }
+                catch {
+                    console.warn(`[IndustryModeRegistry] Skipping corrupt user_modes row '${row.owner}:${row.name}'.`);
+                }
+            }
+        }
+        catch (err) {
+            console.warn("[IndustryModeRegistry] Failed to load persisted user modes:", err.message);
+        }
+    }
+    async persistUserMode(mode) {
+        try {
+            await this.persistence.save(mode.owner, mode.name, JSON.stringify(mode));
+        }
+        catch (err) {
+            console.warn(`[IndustryModeRegistry] Failed to persist user mode '${mode.owner}:${mode.name}':`, err.message);
+        }
+    }
+    async unpersistUserMode(owner, name) {
+        try {
+            await this.persistence.delete(owner, name);
+        }
+        catch (err) {
+            console.warn(`[IndustryModeRegistry] Failed to delete persisted user mode '${owner}:${name}':`, err.message);
+        }
+    }
     bumpPatchVersion(version) {
-        const parts = version.replace(/^v/, "").split(".");
+        const stripped = version.replace(/^v/, "");
+        const parts = stripped.split(".");
         if (parts.length < 2)
-            return `v${version}.1`;
+            return `v${stripped}.1`;
         const patch = parseInt(parts[1] ?? "0", 10);
         parts[1] = String(patch + 1);
         return `v${parts.join(".")}`;
     }
-    applyTemplate(name, intent, context) {
+    async applyTemplate(name, intent, context) {
         const builtinMode = this.getMode(name);
         if (builtinMode) {
             const blueprint = this.doApplyTemplate(builtinMode, intent, context);
@@ -232,7 +287,7 @@ export class IndustryModeRegistry {
         }
         if (name.includes(":")) {
             const [owner, modeName] = name.split(":", 2);
-            const userMode = this.getUserMode(modeName, owner);
+            const userMode = await this.getUserMode(modeName, owner);
             if (userMode) {
                 const blueprint = this.doApplyTemplate(userMode, intent, context);
                 this.recordCapabilitiesUsed(userMode);
@@ -247,8 +302,8 @@ export class IndustryModeRegistry {
         this.recordCapabilitiesUsed(general);
         return blueprint;
     }
-    applyUserMode(modeName, userId, intent, context) {
-        const userMode = this.getUserMode(modeName, userId);
+    async applyUserMode(modeName, userId, intent, context) {
+        const userMode = await this.getUserMode(modeName, userId);
         if (!userMode) {
             throw new Error(`User mode '${modeName}' not found for user '${userId}'`);
         }
@@ -659,4 +714,4 @@ export class IndustryModeRegistry {
 export function getIndustryModeRegistry() {
     return IndustryModeRegistry.Instance();
 }
-export const INDUSTRY_MODE_REGISTRY_VERSION = 2.1;
+export const INDUSTRY_MODE_REGISTRY_VERSION = 2.2;

package/dist/extensions/types.d.ts

@@ -111,6 +111,7 @@ export interface IndustryMode {
     applicable_conditions: ModeApplicableConditions;
     similar_industries?: string[];
     novel_capabilities?: string[];
+    disabled_builtin_constraints?: string[];
 }
 export interface UserDefinedMode extends IndustryMode {
     owner: string;