opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/config/schema/background-task.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+/** Idle-parent wake scheduler settings (default ON, default interval 300000ms, minimum 60000ms) */
+export declare const WakeSchedulerConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    intervalMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Job-board snapshot settings (defaults: enabled true, strategy "latest", maxRetainedSnapshots 20) */
+export declare const JobBoardConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        latest: "latest";
+        "checkpoint-compatible": "checkpoint-compatible";
+    }>>;
+    maxRetainedSnapshots: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const BackgroundTaskConfigSchema: z.ZodObject<{
+    defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+    providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    handleTtlMs: z.ZodOptional<z.ZodNumber>;
+    maxToolCalls: z.ZodOptional<z.ZodNumber>;
+    circuitBreaker: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        maxToolCalls: z.ZodOptional<z.ZodNumber>;
+        consecutiveThreshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    wakeScheduler: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        intervalMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    jobBoard: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            latest: "latest";
+            "checkpoint-compatible": "checkpoint-compatible";
+        }>>;
+        maxRetainedSnapshots: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    wallClockTimeoutMs: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodNumber]>>;
+    wallClockAbortGraceMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>;

package/dist/config/schema/browser-automation.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const BrowserAutomationProviderSchema: z.ZodEnum<{
+    playwright: "playwright";
+    "agent-browser": "agent-browser";
+    "dev-browser": "dev-browser";
+    "playwright-cli": "playwright-cli";
+}>;
+export declare const BrowserAutomationConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        playwright: "playwright";
+        "agent-browser": "agent-browser";
+        "dev-browser": "dev-browser";
+        "playwright-cli": "playwright-cli";
+    }>>;
+}, z.core.$strip>;
+export type BrowserAutomationProvider = z.infer<typeof BrowserAutomationProviderSchema>;
+export type BrowserAutomationConfig = z.infer<typeof BrowserAutomationConfigSchema>;

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export declare const CategoryConfigSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodObject<{
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    system: z.ZodOptional<z.ZodString>;
+    system_append: z.ZodOptional<z.ZodString>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    steps: z.ZodOptional<z.ZodNumber>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        resource: z.ZodString;
+        effect: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>;
+    }, z.core.$strip>>>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    complexity_downgrades: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const BuiltinCategoryNameSchema: z.ZodEnum<{
+    construct: "construct";
+    source: "source";
+    "deep-jack": "deep-jack";
+    "matrix-bend": "matrix-bend";
+    "bullet-time": "bullet-time";
+    "blue-pill": "blue-pill";
+    "red-pill": "red-pill";
+    broadcast: "broadcast";
+}>;
+export declare const CategoriesConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodObject<{
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    system: z.ZodOptional<z.ZodString>;
+    system_append: z.ZodOptional<z.ZodString>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    steps: z.ZodOptional<z.ZodNumber>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        resource: z.ZodString;
+        effect: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>;
+    }, z.core.$strip>>>;
+    is_unstable_agent: z.ZodOptional<z.ZodBoolean>;
+    fallback_models: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    complexity_downgrades: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>>;
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const BuiltinCommandNameSchema: z.ZodEnum<{
+    "init-deep": "init-deep";
+    "matrix-loop": "matrix-loop";
+    "ulw-loop": "ulw-loop";
+    "cancel-loop": "cancel-loop";
+    refactor: "refactor";
+    "start-work": "start-work";
+    "stop-continuation": "stop-continuation";
+    preset: "preset";
+    "end-ultrawork": "end-ultrawork";
+    handoff: "handoff";
+    research: "research";
+    assembly: "assembly";
+    ultrawork: "ultrawork";
+    "bdd-pipeline": "bdd-pipeline";
+    "plan-review": "plan-review";
+    "quality-audit": "quality-audit";
+    "quality-assurance": "quality-assurance";
+}>;
+export type BuiltinCommandName = z.infer<typeof BuiltinCommandNameSchema>;

package/dist/config/schema/comment-checker.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const CommentCheckerConfigSchema: z.ZodObject<{
+    custom_prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CommentCheckerConfig = z.infer<typeof CommentCheckerConfigSchema>;

package/dist/config/schema/context-mode.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const ContextModeConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    enforce: z.ZodDefault<z.ZodBoolean>;
+    blocked_tools: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        read: "read";
+        grep: "grep";
+        glob: "glob";
+        webfetch: "webfetch";
+        bash: "bash";
+        shell: "shell";
+    }>>>;
+}, z.core.$strip>;
+export type ContextModeConfig = z.infer<typeof ContextModeConfigSchema>;

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

@@ -0,0 +1,367 @@
+import { z } from "zod";
+export declare const DcpCompressOverrideSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        message: "message";
+        range: "range";
+    }>>;
+    permission: z.ZodOptional<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        ask: "ask";
+    }>>;
+    showCompression: z.ZodOptional<z.ZodBoolean>;
+    summaryBuffer: z.ZodOptional<z.ZodBoolean>;
+    maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, 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<{
+    deduplication: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    purgeErrors: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        turns: z.ZodOptional<z.ZodNumber>;
+        protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, 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 DcpCommandsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DcpCommands = z.infer<typeof DcpCommandsSchema>;
+export declare const DcpManualModeSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    automaticStrategies: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type DcpManualMode = z.infer<typeof DcpManualModeSchema>;
+export declare const DcpProfileDefinitionSchema: z.ZodObject<{
+    pruneNotification: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        detailed: "detailed";
+    }>>;
+    pruneNotificationType: z.ZodOptional<z.ZodEnum<{
+        chat: "chat";
+        toast: "toast";
+    }>>;
+    autoUpdate: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    compress: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            message: "message";
+            range: "range";
+        }>>;
+        permission: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        showCompression: z.ZodOptional<z.ZodBoolean>;
+        summaryBuffer: z.ZodOptional<z.ZodBoolean>;
+        maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, 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<{
+        deduplication: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        purgeErrors: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            turns: z.ZodOptional<z.ZodNumber>;
+            protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    commands: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    manualMode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        automaticStrategies: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    protectedFilePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, 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;
+            };
+        };
+    };
+    readonly brutal: {
+        readonly pruneNotification: "off";
+        readonly compress: {
+            readonly maxContextLimit: "20%";
+            readonly minContextLimit: "10%";
+            readonly nudgeFrequency: 2;
+            readonly nudgeForce: "strong";
+            readonly iterationNudgeThreshold: 6;
+        };
+        readonly turnProtection: {
+            readonly enabled: false;
+        };
+        readonly experimental: {
+            readonly allowSubAgents: false;
+        };
+        readonly strategies: {
+            readonly purgeErrors: {
+                readonly turns: 1;
+            };
+        };
+    };
+};
+export declare const DEFAULT_DCP_SHARED: {
+    readonly autoUpdate: false;
+    readonly debug: false;
+    readonly pruneNotificationType: "chat";
+    readonly compress: {
+        readonly mode: "range";
+        readonly permission: "allow";
+        readonly showCompression: true;
+        readonly summaryBuffer: true;
+        readonly nudgeForce: "strong";
+        readonly iterationNudgeThreshold: 5;
+        readonly protectedTools: readonly [];
+        readonly protectUserMessages: false;
+    };
+    readonly strategies: {
+        readonly deduplication: {
+            readonly enabled: true;
+            readonly protectedTools: readonly [];
+        };
+        readonly purgeErrors: {
+            readonly enabled: true;
+            readonly protectedTools: readonly [];
+        };
+    };
+    readonly commands: {
+        readonly enabled: true;
+        readonly protectedTools: readonly [];
+    };
+    readonly manualMode: {
+        readonly enabled: false;
+        readonly automaticStrategies: true;
+    };
+    readonly protectedFilePatterns: readonly [];
+    readonly experimental: {
+        readonly allowSubAgents: true;
+    };
+};
+/**
+ * Configuration for compressing background task results when sending
+ * completion notifications to the parent session (handoff boundary).
+ *
+ * When enabled, assistant messages beyond `maxMessages` are truncated:
+ * the first `keepFirst` and last `keepLast` messages are preserved,
+ * with a "[... N messages truncated]" marker inserted between them.
+ * This reduces the context cost of notifying the parent session.
+ */
+export declare const DcpHandoffCompressionSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxMessages: z.ZodDefault<z.ZodNumber>;
+    keepFirst: z.ZodDefault<z.ZodNumber>;
+    keepLast: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DcpHandoffCompression = z.infer<typeof DcpHandoffCompressionSchema>;
+export declare const DcpConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        pruneNotification: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            detailed: "detailed";
+        }>>;
+        pruneNotificationType: z.ZodOptional<z.ZodEnum<{
+            chat: "chat";
+            toast: "toast";
+        }>>;
+        autoUpdate: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        compress: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                message: "message";
+                range: "range";
+            }>>;
+            permission: z.ZodOptional<z.ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                ask: "ask";
+            }>>;
+            showCompression: z.ZodOptional<z.ZodBoolean>;
+            summaryBuffer: z.ZodOptional<z.ZodBoolean>;
+            maxContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            minContextLimit: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            modelMaxLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+            modelMinLimits: z.ZodOptional<z.ZodRecord<z.ZodString, 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<{
+            deduplication: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            purgeErrors: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                turns: z.ZodOptional<z.ZodNumber>;
+                protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        commands: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            protectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        manualMode: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            automaticStrategies: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        protectedFilePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    default_profile: z.ZodOptional<z.ZodString>;
+    handoffCompression: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxMessages: z.ZodDefault<z.ZodNumber>;
+        keepFirst: z.ZodDefault<z.ZodNumber>;
+        keepLast: z.ZodDefault<z.ZodNumber>;
+    }, 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/experimental.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const ExperimentalConfigSchema: z.ZodObject<{
+    aggressive_truncation: z.ZodOptional<z.ZodBoolean>;
+    auto_resume: z.ZodOptional<z.ZodBoolean>;
+    preemptive_compaction: z.ZodOptional<z.ZodBoolean>;
+    truncate_all_tool_outputs: z.ZodOptional<z.ZodBoolean>;
+    task_system: z.ZodOptional<z.ZodBoolean>;
+    plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
+    context_warning_threshold: z.ZodOptional<z.ZodNumber>;
+    preemptive_compaction_threshold: z.ZodOptional<z.ZodNumber>;
+    safe_hook_creation: z.ZodOptional<z.ZodBoolean>;
+    hashline_edit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;

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
+ *   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>;