opencode-matrixx 2.4.0 → 2.6.0

package/dist/config/index.d.ts

@@ -1,3 +1,3 @@
 export { expandPreset, PRESET_NAMES, type PresetName } from "./presets";
-export type { AgentDefinitions, AgentName, AgentOverrideConfig, AgentOverrides, BuiltinCommandName, EnvFileGuardConfig, ExperimentalConfig, HookName, MatrixLoopConfig, MatrixxConfig, McpName, ModelCapabilitiesConfig, MorpheusAgentConfig, MorpheusConfig, MorpheusTasksConfig, RuntimeFallbackConfig, SecretScanningConfig, SecurityConfig, TmuxConfig, TmuxLayout, } from "./schema";
+export type { AgentDefinitions, AgentName, AgentOverrideConfig, AgentOverrides, BuiltinCommandName, EnvFileGuardConfig, ExperimentalConfig, HookName, MatrixLoopConfig, MatrixxConfig, McpName, MorpheusAgentConfig, MorpheusConfig, MorpheusTasksConfig, RuntimeFallbackConfig, SecretScanningConfig, SecurityConfig, TmuxConfig, TmuxLayout, } from "./schema";
 export { AgentOverrideConfigSchema, AgentOverridesSchema, BuiltinCommandNameSchema, ExperimentalConfigSchema, HookNameSchema, MatrixLoopConfigSchema, MatrixxConfigSchema, McpNameSchema, MorpheusAgentConfigSchema, RuntimeFallbackConfigSchema, SecurityConfigSchema, TmuxConfigSchema, TmuxLayoutSchema, } from "./schema";

package/dist/config/schema/dcp.d.ts

@@ -7,10 +7,239 @@ import { z } from "zod";
  *
  * DCP must be installed as a plugin: `~/.config/opencode/node_modules/@tarquinen/opencode-dcp`
  */
+export declare const DcpCompressOverrideSchema: z.ZodObject<{
+    maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    nudgeFrequency: z.ZodOptional<z.ZodNumber>;
+    iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
+    nudgeForce: z.ZodOptional<z.ZodEnum<{
+        strong: "strong";
+        soft: "soft";
+    }>>;
+    protectTags: z.ZodOptional<z.ZodBoolean>;
+    protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    protectUserMessages: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type DcpCompressOverride = z.infer<typeof DcpCompressOverrideSchema>;
+export declare const DcpStrategiesOverrideSchema: z.ZodObject<{
+    purgeErrors: z.ZodOptional<z.ZodObject<{
+        turns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DcpStrategiesOverride = z.infer<typeof DcpStrategiesOverrideSchema>;
+export declare const DcpTurnProtectionSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    turns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DcpTurnProtection = z.infer<typeof DcpTurnProtectionSchema>;
+export declare const DcpExperimentalSchema: z.ZodObject<{
+    allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type DcpExperimental = z.infer<typeof DcpExperimentalSchema>;
+export declare const DcpProfileDefinitionSchema: z.ZodObject<{
+    pruneNotification: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        detailed: "detailed";
+    }>>;
+    compress: z.ZodOptional<z.ZodObject<{
+        maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        nudgeFrequency: z.ZodOptional<z.ZodNumber>;
+        iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
+        nudgeForce: z.ZodOptional<z.ZodEnum<{
+            strong: "strong";
+            soft: "soft";
+        }>>;
+        protectTags: z.ZodOptional<z.ZodBoolean>;
+        protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        protectUserMessages: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    turnProtection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        turns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    experimental: z.ZodOptional<z.ZodObject<{
+        allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    strategies: z.ZodOptional<z.ZodObject<{
+        purgeErrors: z.ZodOptional<z.ZodObject<{
+            turns: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DcpProfileDefinition = z.infer<typeof DcpProfileDefinitionSchema>;
+export declare const BUILTIN_DCP_PROFILES: {
+    readonly economy: {
+        readonly pruneNotification: "off";
+        readonly compress: {
+            readonly maxContextLimit: "30%";
+            readonly minContextLimit: "20%";
+            readonly nudgeFrequency: 2;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 7;
+        };
+        readonly turnProtection: {
+            readonly enabled: false;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: false;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 1;
+            };
+        };
+    };
+    readonly balanced: {
+        readonly pruneNotification: "minimal";
+        readonly compress: {
+            readonly maxContextLimit: "60%";
+            readonly minContextLimit: "30%";
+            readonly nudgeFrequency: 3;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 10;
+        };
+        readonly turnProtection: {
+            readonly enabled: true;
+            readonly turns: 2;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: true;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 2;
+            };
+        };
+    };
+    readonly performance: {
+        readonly pruneNotification: "minimal";
+        readonly compress: {
+            readonly maxContextLimit: "80%";
+            readonly minContextLimit: "35%";
+            readonly nudgeFrequency: 4;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 12;
+        };
+        readonly turnProtection: {
+            readonly enabled: true;
+            readonly turns: 3;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: true;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 2;
+            };
+        };
+    };
+    readonly ultimate: {
+        readonly pruneNotification: "detailed";
+        readonly compress: {
+            readonly maxContextLimit: "85%";
+            readonly minContextLimit: "40%";
+            readonly nudgeFrequency: 5;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 15;
+            readonly protectTags: true;
+        };
+        readonly turnProtection: {
+            readonly enabled: true;
+            readonly turns: 5;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: true;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 4;
+            };
+        };
+    };
+};
 export declare const DcpConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
-    switch_script: z.ZodOptional<z.ZodString>;
-    profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        pruneNotification: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            detailed: "detailed";
+        }>>;
+        compress: z.ZodOptional<z.ZodObject<{
+            maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            nudgeFrequency: z.ZodOptional<z.ZodNumber>;
+            iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
+            nudgeForce: z.ZodOptional<z.ZodEnum<{
+                strong: "strong";
+                soft: "soft";
+            }>>;
+            protectTags: z.ZodOptional<z.ZodBoolean>;
+            protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            protectUserMessages: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        turnProtection: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            turns: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        experimental: z.ZodOptional<z.ZodObject<{
+            allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        strategies: z.ZodOptional<z.ZodObject<{
+            purgeErrors: z.ZodOptional<z.ZodObject<{
+                turns: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     default_profile: z.ZodOptional<z.ZodString>;
+    base: z.ZodDefault<z.ZodObject<{
+        autoUpdate: z.ZodDefault<z.ZodBoolean>;
+        debug: z.ZodDefault<z.ZodBoolean>;
+        pruneNotificationType: z.ZodDefault<z.ZodEnum<{
+            chat: "chat";
+            toast: "toast";
+        }>>;
+        compress: z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                message: "message";
+                range: "range";
+            }>>;
+            permission: z.ZodDefault<z.ZodEnum<{
+                ask: "ask";
+                allow: "allow";
+                deny: "deny";
+            }>>;
+            showCompression: z.ZodDefault<z.ZodBoolean>;
+            summaryBuffer: z.ZodDefault<z.ZodBoolean>;
+            nudgeForce: z.ZodDefault<z.ZodEnum<{
+                strong: "strong";
+                soft: "soft";
+            }>>;
+            iterationNudgeThreshold: z.ZodDefault<z.ZodNumber>;
+            protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            protectUserMessages: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        strategies: z.ZodDefault<z.ZodObject<{
+            deduplication: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            purgeErrors: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        commands: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        manualMode: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            automaticStrategies: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        protectedFilePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type DcpConfig = z.infer<typeof DcpConfigSchema>;

package/dist/config/schema/evolution.d.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+export declare const EvolutionWatcherConfigSchema: z.ZodDefault<z.ZodObject<{
+    maxArgChars: z.ZodDefault<z.ZodNumber>;
+    maxOutputChars: z.ZodDefault<z.ZodNumber>;
+    skipTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+export type EvolutionWatcherConfig = z.infer<typeof EvolutionWatcherConfigSchema>;
+export declare const EvolutionCompressorConfigSchema: z.ZodDefault<z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        llm: "llm";
+        "dspy-gepa": "dspy-gepa";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    minTraces: z.ZodDefault<z.ZodNumber>;
+    maxInputTokens: z.ZodDefault<z.ZodNumber>;
+    trigger: z.ZodDefault<z.ZodEnum<{
+        compacting: "compacting";
+        idle: "idle";
+        both: "both";
+    }>>;
+}, z.core.$strip>>;
+export type EvolutionCompressorConfig = z.infer<typeof EvolutionCompressorConfigSchema>;
+export declare const EvolutionWriterConfigSchema: z.ZodDefault<z.ZodObject<{
+    outputDir: z.ZodDefault<z.ZodString>;
+    globalSkills: z.ZodDefault<z.ZodBoolean>;
+    allowToolGeneration: z.ZodDefault<z.ZodBoolean>;
+    allowAgentGeneration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type EvolutionWriterConfig = z.infer<typeof EvolutionWriterConfigSchema>;
+export declare const EvolutionGovernanceConfigSchema: z.ZodDefault<z.ZodObject<{
+    requireApproval: z.ZodDefault<z.ZodBoolean>;
+    autoPromote: z.ZodDefault<z.ZodBoolean>;
+    autoPromoteThreshold: z.ZodDefault<z.ZodNumber>;
+    minConfidence: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export type EvolutionGovernanceConfig = z.infer<typeof EvolutionGovernanceConfigSchema>;
+export declare const EvolutionRetentionConfigSchema: z.ZodDefault<z.ZodObject<{
+    traceDays: z.ZodDefault<z.ZodNumber>;
+    maxPending: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export type EvolutionRetentionConfig = z.infer<typeof EvolutionRetentionConfigSchema>;
+export declare const EvolutionBudgetConfigSchema: z.ZodDefault<z.ZodObject<{
+    maxCompressionsPerHour: z.ZodDefault<z.ZodNumber>;
+    maxCostCentsPerDay: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export type EvolutionBudgetConfig = z.infer<typeof EvolutionBudgetConfigSchema>;
+export declare const EvolutionConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    watcher: z.ZodDefault<z.ZodObject<{
+        maxArgChars: z.ZodDefault<z.ZodNumber>;
+        maxOutputChars: z.ZodDefault<z.ZodNumber>;
+        skipTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    compressor: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            llm: "llm";
+            "dspy-gepa": "dspy-gepa";
+        }>>;
+        model: z.ZodOptional<z.ZodString>;
+        minTraces: z.ZodDefault<z.ZodNumber>;
+        maxInputTokens: z.ZodDefault<z.ZodNumber>;
+        trigger: z.ZodDefault<z.ZodEnum<{
+            compacting: "compacting";
+            idle: "idle";
+            both: "both";
+        }>>;
+    }, z.core.$strip>>;
+    writer: z.ZodDefault<z.ZodObject<{
+        outputDir: z.ZodDefault<z.ZodString>;
+        globalSkills: z.ZodDefault<z.ZodBoolean>;
+        allowToolGeneration: z.ZodDefault<z.ZodBoolean>;
+        allowAgentGeneration: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    governance: z.ZodDefault<z.ZodObject<{
+        requireApproval: z.ZodDefault<z.ZodBoolean>;
+        autoPromote: z.ZodDefault<z.ZodBoolean>;
+        autoPromoteThreshold: z.ZodDefault<z.ZodNumber>;
+        minConfidence: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    retention: z.ZodDefault<z.ZodObject<{
+        traceDays: z.ZodDefault<z.ZodNumber>;
+        maxPending: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        maxCompressionsPerHour: z.ZodDefault<z.ZodNumber>;
+        maxCostCentsPerDay: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EvolutionConfig = z.infer<typeof EvolutionConfigSchema>;

package/dist/config/schema/headroom.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+/**
+ * Headroom network-proxy compression configuration.
+ *
+ * Headroom is an external network-proxy that compresses LLM traffic
+ * (CacheAligner → ContentRouter → CCR pipeline). Matrixx does NOT
+ * implement compression itself — it only detects/disciplines when
+ * Headroom is active.
+ *
+ * - Opt-in via `enabled: true` (default: false).
+ * - Recommended usage is `HEADROOM_WRAP=1 headroom wrap -- <command>`
+ *   so the proxy sits transparently in front of the transport.
+ * - Native transport integration is deferred until the compaction hook
+ *   stabilizes (Headroom #76 collision risk with
+ *   anthropic-context-window-limit-recovery).
+ */
+export declare const HeadroomConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    proxyUrl: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    backend: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HeadroomConfig = z.infer<typeof HeadroomConfigSchema>;

package/dist/config/schema/hooks.d.ts

@@ -4,6 +4,8 @@ export declare const HookNameSchema: z.ZodEnum<{
     "quality-gate": "quality-gate";
     "matrix-loop": "matrix-loop";
     "start-work": "start-work";
+    "evolution-watcher": "evolution-watcher";
+    "evolution-compressor": "evolution-compressor";
     "todo-continuation-enforcer": "todo-continuation-enforcer";
     "context-window-monitor": "context-window-monitor";
     "session-recovery": "session-recovery";
@@ -33,7 +35,7 @@ export declare const HookNameSchema: z.ZodEnum<{
     "auto-slash-command": "auto-slash-command";
     "edit-error-recovery": "edit-error-recovery";
     "delegate-task-retry": "delegate-task-retry";
-    "prometheus-md-only": "prometheus-md-only";
+    "oracle-md-only": "oracle-md-only";
     "plan-persister": "plan-persister";
     "mouse-notepad": "mouse-notepad";
     "unstable-agent-babysitter": "unstable-agent-babysitter";
@@ -55,7 +57,11 @@ export declare const HookNameSchema: z.ZodEnum<{
     "hashline-edit-diff-enhancer": "hashline-edit-diff-enhancer";
     "tool-pair-validator": "tool-pair-validator";
     "task-notepad": "task-notepad";
+    "task-todo-mirror": "task-todo-mirror";
     "design-intent-preserver": "design-intent-preserver";
     "rtk-bash-rewriter": "rtk-bash-rewriter";
+    "mcp-startup-notification": "mcp-startup-notification";
+    "evolution-quality-gate": "evolution-quality-gate";
+    "evolution-hitl": "evolution-hitl";
 }>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/matrixx-config.d.ts

@@ -72,6 +72,8 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "quality-gate": "quality-gate";
         "matrix-loop": "matrix-loop";
         "start-work": "start-work";
+        "evolution-watcher": "evolution-watcher";
+        "evolution-compressor": "evolution-compressor";
         "todo-continuation-enforcer": "todo-continuation-enforcer";
         "context-window-monitor": "context-window-monitor";
         "session-recovery": "session-recovery";
@@ -101,7 +103,7 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "auto-slash-command": "auto-slash-command";
         "edit-error-recovery": "edit-error-recovery";
         "delegate-task-retry": "delegate-task-retry";
-        "prometheus-md-only": "prometheus-md-only";
+        "oracle-md-only": "oracle-md-only";
         "plan-persister": "plan-persister";
         "mouse-notepad": "mouse-notepad";
         "unstable-agent-babysitter": "unstable-agent-babysitter";
@@ -123,8 +125,12 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "hashline-edit-diff-enhancer": "hashline-edit-diff-enhancer";
         "tool-pair-validator": "tool-pair-validator";
         "task-notepad": "task-notepad";
+        "task-todo-mirror": "task-todo-mirror";
         "design-intent-preserver": "design-intent-preserver";
         "rtk-bash-rewriter": "rtk-bash-rewriter";
+        "mcp-startup-notification": "mcp-startup-notification";
+        "evolution-quality-gate": "evolution-quality-gate";
+        "evolution-hitl": "evolution-hitl";
     }>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "bdd-contract": "bdd-contract";
@@ -1689,9 +1695,86 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     dcp: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        switch_script: z.ZodOptional<z.ZodString>;
-        profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            pruneNotification: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                minimal: "minimal";
+                detailed: "detailed";
+            }>>;
+            compress: z.ZodOptional<z.ZodObject<{
+                maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+                minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+                nudgeFrequency: z.ZodOptional<z.ZodNumber>;
+                iterationNudgeThreshold: z.ZodOptional<z.ZodNumber>;
+                nudgeForce: z.ZodOptional<z.ZodEnum<{
+                    strong: "strong";
+                    soft: "soft";
+                }>>;
+                protectTags: z.ZodOptional<z.ZodBoolean>;
+                protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                protectUserMessages: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            turnProtection: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                turns: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            experimental: z.ZodOptional<z.ZodObject<{
+                allowSubAgents: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            strategies: z.ZodOptional<z.ZodObject<{
+                purgeErrors: z.ZodOptional<z.ZodObject<{
+                    turns: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
         default_profile: z.ZodOptional<z.ZodString>;
+        base: z.ZodDefault<z.ZodObject<{
+            autoUpdate: z.ZodDefault<z.ZodBoolean>;
+            debug: z.ZodDefault<z.ZodBoolean>;
+            pruneNotificationType: z.ZodDefault<z.ZodEnum<{
+                chat: "chat";
+                toast: "toast";
+            }>>;
+            compress: z.ZodDefault<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<{
+                    message: "message";
+                    range: "range";
+                }>>;
+                permission: z.ZodDefault<z.ZodEnum<{
+                    ask: "ask";
+                    allow: "allow";
+                    deny: "deny";
+                }>>;
+                showCompression: z.ZodDefault<z.ZodBoolean>;
+                summaryBuffer: z.ZodDefault<z.ZodBoolean>;
+                nudgeForce: z.ZodDefault<z.ZodEnum<{
+                    strong: "strong";
+                    soft: "soft";
+                }>>;
+                iterationNudgeThreshold: z.ZodDefault<z.ZodNumber>;
+                protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                protectUserMessages: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            strategies: z.ZodDefault<z.ZodObject<{
+                deduplication: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                purgeErrors: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            commands: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                protectedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            manualMode: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                automaticStrategies: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            protectedFilePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
     skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
@@ -1815,21 +1898,63 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         notify_on_fallback: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, z.core.$strip>>;
     agent_definitions: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    model_capabilities: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        auto_refresh_on_start: z.ZodOptional<z.ZodBoolean>;
-        refresh_timeout_ms: z.ZodOptional<z.ZodNumber>;
-        source_url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
     matrixx_self_config: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         proactive: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    headroom: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        backend: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     rtk: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         binary_path: z.ZodOptional<z.ZodString>;
         timeout_ms: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    evolution: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        watcher: z.ZodDefault<z.ZodObject<{
+            maxArgChars: z.ZodDefault<z.ZodNumber>;
+            maxOutputChars: z.ZodDefault<z.ZodNumber>;
+            skipTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        compressor: z.ZodDefault<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodEnum<{
+                llm: "llm";
+                "dspy-gepa": "dspy-gepa";
+            }>>;
+            model: z.ZodOptional<z.ZodString>;
+            minTraces: z.ZodDefault<z.ZodNumber>;
+            maxInputTokens: z.ZodDefault<z.ZodNumber>;
+            trigger: z.ZodDefault<z.ZodEnum<{
+                compacting: "compacting";
+                idle: "idle";
+                both: "both";
+            }>>;
+        }, z.core.$strip>>;
+        writer: z.ZodDefault<z.ZodObject<{
+            outputDir: z.ZodDefault<z.ZodString>;
+            globalSkills: z.ZodDefault<z.ZodBoolean>;
+            allowToolGeneration: z.ZodDefault<z.ZodBoolean>;
+            allowAgentGeneration: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        governance: z.ZodDefault<z.ZodObject<{
+            requireApproval: z.ZodDefault<z.ZodBoolean>;
+            autoPromote: z.ZodDefault<z.ZodBoolean>;
+            autoPromoteThreshold: z.ZodDefault<z.ZodNumber>;
+            minConfidence: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        retention: z.ZodDefault<z.ZodObject<{
+            traceDays: z.ZodDefault<z.ZodNumber>;
+            maxPending: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        budget: z.ZodDefault<z.ZodObject<{
+            maxCompressionsPerHour: z.ZodDefault<z.ZodNumber>;
+            maxCostCentsPerDay: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     _migrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type MatrixxConfig = z.infer<typeof MatrixxConfigSchema>;

package/dist/config/schema.d.ts

@@ -8,15 +8,15 @@ export * from "./schema/background-task";
 export * from "./schema/browser-automation";
 export * from "./schema/categories";
 export * from "./schema/commands";
-export * from "./schema/commands";
 export * from "./schema/comment-checker";
 export * from "./schema/dcp";
+export * from "./schema/evolution";
 export * from "./schema/experimental";
-export * from "./schema/experimental";
+export * from "./schema/headroom";
 export * from "./schema/hooks";
 export * from "./schema/matrix-loop";
 export * from "./schema/matrixx-config";
-export * from "./schema/model-capabilities";
+export * from "./schema/matrixx-self-config";
 export * from "./schema/morpheus";
 export * from "./schema/morpheus-agent";
 export * from "./schema/notification";

package/dist/create-hooks.d.ts

@@ -1,7 +1,7 @@
 import type { AvailableSkill } from "./agents/dynamic-agent-prompt-builder";
 import type { HookName, MatrixxConfig } from "./config";
 import type { BackgroundManager } from "./features/background-agent";
-import type { LoadedSkill } from "./features/opencode-skill-loader/types";
+import type { BuiltinSkill } from "./features/builtin-skills";
 import type { PluginContext } from "./plugin/types";
 export type CreatedHooks = ReturnType<typeof createHooks>;
 export declare function createHooks(args: {
@@ -10,7 +10,7 @@ export declare function createHooks(args: {
     backgroundManager: BackgroundManager;
     isHookEnabled: (hookName: HookName) => boolean;
     safeHookEnabled: boolean;
-    mergedSkills: LoadedSkill[];
+    builtinSkills: BuiltinSkill[];
     availableSkills: AvailableSkill[];
 }): {
     categorySkillReminder: ReturnType<typeof import("./hooks").createCategorySkillReminderHook> | null;
@@ -23,6 +23,8 @@ export declare function createHooks(args: {
     backgroundNotificationHook: ReturnType<typeof import("./hooks").createBackgroundNotificationHook> | null;
     architectHook: ReturnType<typeof import("./hooks").createArchitectHook> | null;
     planPersister: ReturnType<typeof import("./hooks").createPlanPersister> | null;
+    evolutionCompressor: ReturnType<typeof import("./hooks").createEvolutionCompressorHook> | null;
+    evolutionHitl: ReturnType<typeof import("./hooks").createEvolutionHitlHook> | null;
     keywordDetector: ReturnType<typeof import("./hooks").createKeywordDetectorHook> | null;
     contextInjectorMessagesTransform: ReturnType<typeof import("./features/context-injector").createContextInjectorMessagesTransformHook>;
     envContextInjector: ReturnType<typeof import("./hooks").createEnvContextInjectorHook> | null;
@@ -48,6 +50,8 @@ export declare function createHooks(args: {
     hashlineEditDiffEnhancer: ReturnType<typeof import("./hooks").createHashlineEditDiffEnhancerHook> | null;
     qualityGate: ReturnType<typeof import("./hooks").createQualityGateHook> | null;
     taskNotepad: ReturnType<typeof import("./hooks").createTaskNotepadHook> | null;
+    evolutionWatcher: ReturnType<typeof import("./hooks").createEvolutionWatcherHook> | null;
+    taskTodoMirror: ReturnType<typeof import("./hooks").createTaskTodoMirrorHook> | null;
     contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;
     sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;
@@ -62,11 +66,12 @@ export declare function createHooks(args: {
     editErrorRecovery: ReturnType<typeof import("./hooks").createEditErrorRecoveryHook> | null;
     delegateTaskRetry: ReturnType<typeof import("./hooks").createDelegateTaskRetryHook> | null;
     startWork: ReturnType<typeof import("./hooks").createStartWorkHook> | null;
-    prometheusMdOnly: ReturnType<typeof import("./hooks").createOracleMdOnlyHook> | null;
+    oracleMdOnly: ReturnType<typeof import("./hooks").createOracleMdOnlyHook> | null;
     mouseNotepad: ReturnType<typeof import("./hooks").createMouseNotepadHook> | null;
     questionLabelTruncator: ReturnType<typeof import("./hooks").createQuestionLabelTruncatorHook>;
     taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook>;
     anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
     runtimeFallback: ReturnType<typeof import("./hooks").createRuntimeFallbackHook> | null;
     rtkBashRewriter: ReturnType<typeof import("./hooks").createRtkBashRewriterHook> | null;
+    mcpStartupNotification: ReturnType<typeof import("./hooks").createMcpStartupNotificationHook> | null;
 };

package/dist/create-managers.d.ts

@@ -1,6 +1,5 @@
 import type { MatrixxConfig } from "./config";
 import { BackgroundManager } from "./features/background-agent";
-import { SkillMcpManager } from "./features/skill-mcp-manager";
 import { TmuxSessionManager } from "./features/tmux-subagent";
 import type { PluginContext, TmuxConfig } from "./plugin/types";
 import { createConfigHandler } from "./plugin-handlers";
@@ -8,7 +7,6 @@ import type { ModelCacheState } from "./plugin-state";
 export type Managers = {
     tmuxSessionManager: TmuxSessionManager;
     backgroundManager: BackgroundManager;
-    skillMcpManager: SkillMcpManager;
     configHandler: ReturnType<typeof createConfigHandler>;
 };
 export declare function createManagers(args: {