@mxf-dev/core 1.0.0

package/src/config/FeatureFlags.ts

@@ -0,0 +1,180 @@
+/**
+ * Feature Flags Configuration
+ *
+ * Centralized feature flag configuration for MXF enhancements (P6-P9).
+ * All features are disabled by default and can be enabled via environment variables.
+ */
+
+import { Logger } from '../utils/Logger.js';
+
+const logger = new Logger('info', 'FeatureFlags', 'server');
+
+/**
+ * Feature flag configuration interface
+ */
+export interface FeatureFlagsConfig {
+  /** LSP-MCP Bridge integration (P7) */
+  lspEnabled: boolean;
+
+  /** Agent Dev Kit / Workflow System (P6) */
+  workflowSystemEnabled: boolean;
+
+  /** Memory Strata (P8) */
+  memoryStrataEnabled: boolean;
+
+  /** Decentralization / P2P (P9) */
+  decentralizationEnabled: boolean;
+
+  /** Sub-features for LSP */
+  lsp: {
+    /** Enable TypeScript language server */
+    typescript: boolean;
+    /** Enable Python language server */
+    python: boolean;
+    /** Enable Go language server */
+    go: boolean;
+    /** Enable caching for LSP responses */
+    caching: boolean;
+  };
+
+  /** Sub-features for Workflow System */
+  workflow: {
+    /** Enable workflow templates */
+    templates: boolean;
+    /** Enable workflow execution */
+    execution: boolean;
+    /** Enable workflow validation */
+    validation: boolean;
+  };
+
+  /** Sub-features for Memory Strata */
+  memoryStrata: {
+    /** Enable surprise detection */
+    surpriseDetection: boolean;
+    /** Enable memory consolidation */
+    consolidation: boolean;
+    /** Enable pattern detection */
+    patternDetection: boolean;
+  };
+
+  /** Sub-features for Decentralization */
+  decentralization: {
+    /** Enable peer discovery */
+    peerDiscovery: boolean;
+    /** Enable gossip protocol */
+    gossip: boolean;
+    /** Enable DHT */
+    dht: boolean;
+    /** Enable consensus */
+    consensus: boolean;
+  };
+}
+
+/**
+ * Parse boolean from environment variable
+ */
+function parseBooleanEnv(value: string | undefined, defaultValue: boolean): boolean {
+  if (value === undefined) {
+    return defaultValue;
+  }
+  return value.toLowerCase() === 'true' || value === '1';
+}
+
+/**
+ * Load feature flags from environment variables
+ */
+export function loadFeatureFlags(): FeatureFlagsConfig {
+  const config: FeatureFlagsConfig = {
+    // Main features (all disabled by default)
+    lspEnabled: parseBooleanEnv(process.env.LSP_ENABLED, false),
+    workflowSystemEnabled: parseBooleanEnv(process.env.WORKFLOW_SYSTEM_ENABLED, false),
+    memoryStrataEnabled: parseBooleanEnv(process.env.MEMORY_STRATA_ENABLED, false),
+    decentralizationEnabled: parseBooleanEnv(process.env.DECENTRALIZATION_ENABLED, false),
+
+    // LSP sub-features
+    lsp: {
+      typescript: parseBooleanEnv(process.env.LSP_TYPESCRIPT_ENABLED, true),
+      python: parseBooleanEnv(process.env.LSP_PYTHON_ENABLED, false),
+      go: parseBooleanEnv(process.env.LSP_GO_ENABLED, false),
+      caching: parseBooleanEnv(process.env.LSP_CACHING_ENABLED, true),
+    },
+
+    // Workflow sub-features
+    workflow: {
+      templates: parseBooleanEnv(process.env.WORKFLOW_TEMPLATES_ENABLED, true),
+      execution: parseBooleanEnv(process.env.WORKFLOW_EXECUTION_ENABLED, true),
+      validation: parseBooleanEnv(process.env.WORKFLOW_VALIDATION_ENABLED, true),
+    },
+
+    // Memory Strata sub-features
+    memoryStrata: {
+      surpriseDetection: parseBooleanEnv(process.env.MEMORY_STRATA_SURPRISE_DETECTION, true),
+      consolidation: parseBooleanEnv(process.env.MEMORY_STRATA_CONSOLIDATION, true),
+      patternDetection: parseBooleanEnv(process.env.MEMORY_STRATA_PATTERN_DETECTION, true),
+    },
+
+    // Decentralization sub-features
+    decentralization: {
+      peerDiscovery: parseBooleanEnv(process.env.DECENTRALIZATION_PEER_DISCOVERY, true),
+      gossip: parseBooleanEnv(process.env.DECENTRALIZATION_GOSSIP, true),
+      dht: parseBooleanEnv(process.env.DECENTRALIZATION_DHT, false),
+      consensus: parseBooleanEnv(process.env.DECENTRALIZATION_CONSENSUS, false),
+    },
+  };
+
+  // Log enabled features
+  const enabledFeatures: string[] = [];
+  if (config.lspEnabled) enabledFeatures.push('LSP-MCP Bridge');
+  if (config.workflowSystemEnabled) enabledFeatures.push('Workflow System');
+  if (config.memoryStrataEnabled) enabledFeatures.push('Memory Strata');
+  if (config.decentralizationEnabled) enabledFeatures.push('Decentralization');
+
+  if (enabledFeatures.length > 0) {
+    logger.info(`Enabled experimental features: ${enabledFeatures.join(', ')}`);
+  } else {
+    logger.debug('No experimental features enabled (P6-P9 features disabled)');
+  }
+
+  return config;
+}
+
+/**
+ * Global feature flags instance
+ */
+export const FEATURE_FLAGS: FeatureFlagsConfig = loadFeatureFlags();
+
+/**
+ * Helper functions to check feature flags
+ */
+export const isLspEnabled = (): boolean => FEATURE_FLAGS.lspEnabled;
+export const isWorkflowSystemEnabled = (): boolean => FEATURE_FLAGS.workflowSystemEnabled;
+export const isMemoryStrataEnabled = (): boolean => FEATURE_FLAGS.memoryStrataEnabled;
+export const isDecentralizationEnabled = (): boolean => FEATURE_FLAGS.decentralizationEnabled;
+
+/**
+ * Guard function to check if a feature is enabled
+ * Throws an error if the feature is disabled
+ */
+export function requireFeature(
+  feature: keyof Pick<FeatureFlagsConfig, 'lspEnabled' | 'workflowSystemEnabled' | 'memoryStrataEnabled' | 'decentralizationEnabled'>,
+  featureName: string
+): void {
+  if (!FEATURE_FLAGS[feature]) {
+    throw new Error(
+      `Feature "${featureName}" is not enabled. ` +
+      `Set ${feature.toUpperCase().replace('ENABLED', '')}=true in environment variables to enable.`
+    );
+  }
+}
+
+/**
+ * Check if any experimental features are enabled
+ */
+export const hasExperimentalFeaturesEnabled = (): boolean => {
+  return (
+    FEATURE_FLAGS.lspEnabled ||
+    FEATURE_FLAGS.workflowSystemEnabled ||
+    FEATURE_FLAGS.memoryStrataEnabled ||
+    FEATURE_FLAGS.decentralizationEnabled
+  );
+};

package/src/config/McpPromptsConfig.ts

@@ -0,0 +1,134 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+
+/**
+ * MCP Prompts Configuration
+ *
+ * Centralized configuration for MCP Prompts feature with environment variable
+ * support and sensible defaults.
+ */
+
+import { MxfPromptsConfig } from '../types/McpPromptTypes.js';
+import { Logger } from '../utils/Logger.js';
+
+const logger = new Logger('info', 'McpPromptsConfig', 'server');
+
+/**
+ * Default configuration for MCP Prompts
+ */
+export const DEFAULT_PROMPTS_CONFIG: MxfPromptsConfig = {
+    enabled: process.env.MCP_PROMPTS_ENABLED !== 'false',
+    cache: {
+        strategy: (process.env.MCP_PROMPTS_CACHE_STRATEGY as any) || 'memory',
+        ttlSeconds: parseInt(process.env.MCP_PROMPTS_CACHE_TTL || '300', 10),
+        maxEntries: parseInt(process.env.MCP_PROMPTS_CACHE_MAX_ENTRIES || '1000', 10)
+    },
+    discovery: {
+        refreshIntervalSeconds: parseInt(process.env.MCP_PROMPTS_REFRESH_INTERVAL || '60', 10),
+        timeoutMs: parseInt(process.env.MCP_PROMPTS_TIMEOUT || '5000', 10)
+    },
+    resolution: {
+        maxEmbeddedResourceSize: parseInt(
+            process.env.MCP_PROMPTS_MAX_RESOURCE_SIZE || String(1024 * 1024),
+            10
+        ),
+        allowedResourceSchemes: process.env.MCP_PROMPTS_ALLOWED_SCHEMES
+            ? process.env.MCP_PROMPTS_ALLOWED_SCHEMES.split(',')
+            : ['resource://', 'file://']
+    },
+    mxpIntegration: {
+        compressEmbeddedResources: process.env.MCP_PROMPTS_COMPRESS_RESOURCES !== 'false',
+        trackTokenUsage: process.env.MCP_PROMPTS_TRACK_TOKENS !== 'false'
+    }
+};
+
+/**
+ * Load prompts configuration from environment or use defaults
+ */
+export function loadPromptsConfig(overrides?: Partial<MxfPromptsConfig>): MxfPromptsConfig {
+    const config: MxfPromptsConfig = {
+        ...DEFAULT_PROMPTS_CONFIG,
+        ...overrides,
+        cache: {
+            ...DEFAULT_PROMPTS_CONFIG.cache,
+            ...(overrides?.cache || {})
+        },
+        discovery: {
+            ...DEFAULT_PROMPTS_CONFIG.discovery,
+            ...(overrides?.discovery || {})
+        },
+        resolution: {
+            ...DEFAULT_PROMPTS_CONFIG.resolution,
+            ...(overrides?.resolution || {})
+        },
+        mxpIntegration: {
+            ...DEFAULT_PROMPTS_CONFIG.mxpIntegration,
+            ...(overrides?.mxpIntegration || {})
+        }
+    };
+
+    logger.info('MCP Prompts configuration loaded', config);
+
+    return config;
+}
+
+/**
+ * Validate prompts configuration
+ */
+export function validatePromptsConfig(config: MxfPromptsConfig): string[] {
+    const errors: string[] = [];
+
+    if (config.cache.ttlSeconds < 0) {
+        errors.push('Cache TTL must be non-negative');
+    }
+
+    if (config.cache.maxEntries < 1) {
+        errors.push('Cache max entries must be at least 1');
+    }
+
+    if (config.discovery.refreshIntervalSeconds < 1) {
+        errors.push('Discovery refresh interval must be at least 1 second');
+    }
+
+    if (config.discovery.timeoutMs < 100) {
+        errors.push('Discovery timeout must be at least 100ms');
+    }
+
+    if (config.resolution.maxEmbeddedResourceSize < 1024) {
+        errors.push('Max embedded resource size must be at least 1KB');
+    }
+
+    if (config.resolution.allowedResourceSchemes.length === 0) {
+        errors.push('At least one resource scheme must be allowed');
+    }
+
+    if (errors.length > 0) {
+        logger.error('MCP Prompts configuration validation failed', { errors });
+    }
+
+    return errors;
+}
+
+/**
+ * Get default configuration
+ */
+export function getDefaultPromptsConfig(): MxfPromptsConfig {
+    return DEFAULT_PROMPTS_CONFIG;
+}

package/src/config/ModelContextLimits.ts

@@ -0,0 +1,154 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+
+/**
+ * Model Context Limits
+ *
+ * Maps model IDs to their context window sizes (in tokens).
+ * Used by percentage-based compaction to know when to trigger.
+ * Generous fallback (128k) for unknown models with a logged warning.
+ */
+
+import { Logger } from '../utils/Logger.js';
+
+const logger = new Logger('info', 'ModelContextLimits', 'server');
+
+/** Default context limit for unknown models */
+const DEFAULT_CONTEXT_LIMIT = 128_000;
+
+/**
+ * Known model context window sizes (tokens).
+ * Keyed by model ID prefix — lookup tries exact match first,
+ * then walks prefixes so "claude-3.5-sonnet-20241022" matches "claude-3.5-sonnet".
+ */
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+    // Claude models
+    'claude-opus-4': 200_000,
+    'claude-sonnet-4': 200_000,
+    'claude-3.5-sonnet': 200_000,
+    'claude-3.5-haiku': 200_000,
+    'claude-3-opus': 200_000,
+    'claude-3-sonnet': 200_000,
+    'claude-3-haiku': 200_000,
+
+    // OpenAI models
+    'gpt-4o': 128_000,
+    'gpt-4o-mini': 128_000,
+    'gpt-4-turbo': 128_000,
+    'gpt-4-1106': 128_000,
+    'gpt-4': 8_192,
+    'gpt-3.5-turbo': 16_385,
+    'o1': 200_000,
+    'o1-mini': 128_000,
+    'o1-preview': 128_000,
+    'o3': 200_000,
+    'o3-mini': 200_000,
+    'o4-mini': 200_000,
+
+    // Google models
+    'gemini-2.5-pro': 1_000_000,
+    'gemini-2.5-flash': 1_000_000,
+    'gemini-2.0-flash': 1_000_000,
+    'gemini-1.5-pro': 2_000_000,
+    'gemini-1.5-flash': 1_000_000,
+
+    // Meta / Llama models
+    'meta-llama/llama-3.3-70b': 131_072,
+    'meta-llama/llama-3.1-405b': 131_072,
+    'meta-llama/llama-3.1-70b': 131_072,
+    'meta-llama/llama-3.1-8b': 131_072,
+
+    // Mistral models
+    'mistral-large': 128_000,
+    'mistral-medium': 32_000,
+    'mistral-small': 32_000,
+
+    // DeepSeek models
+    'deepseek-chat': 128_000,
+    'deepseek-coder': 128_000,
+    'deepseek-r1': 128_000,
+
+    // Qwen models
+    'qwen-2.5-72b': 131_072,
+    'qwen-2.5-coder-32b': 131_072,
+};
+
+/**
+ * Get the context window size (tokens) for a model.
+ * Tries exact match first, then prefix match, then falls back to DEFAULT_CONTEXT_LIMIT.
+ */
+export function getContextLimit(modelId: string): number {
+    // Exact match
+    if (MODEL_CONTEXT_LIMITS[modelId] !== undefined) {
+        return MODEL_CONTEXT_LIMITS[modelId];
+    }
+
+    // Prefix match — find the longest matching prefix
+    let bestMatch = '';
+    for (const key of Object.keys(MODEL_CONTEXT_LIMITS)) {
+        if (modelId.startsWith(key) && key.length > bestMatch.length) {
+            bestMatch = key;
+        }
+    }
+    if (bestMatch) {
+        return MODEL_CONTEXT_LIMITS[bestMatch];
+    }
+
+    // OpenRouter format: "provider/model-name" — try without provider prefix
+    if (modelId.includes('/')) {
+        const modelPart = modelId.split('/').pop()!;
+        const result = getContextLimit(modelPart);
+        if (result !== DEFAULT_CONTEXT_LIMIT) {
+            return result;
+        }
+    }
+
+    logger.warn('Unknown model, using default context limit', {
+        modelId,
+        defaultLimit: DEFAULT_CONTEXT_LIMIT,
+    });
+    return DEFAULT_CONTEXT_LIMIT;
+}
+
+/**
+ * Get the token count at which compaction should trigger for a model.
+ * @param modelId - The model identifier
+ * @param percent - Usage threshold (0.0–1.0), e.g. 0.80 for 80%
+ */
+export function getCompactionThreshold(modelId: string, percent: number): number {
+    const limit = getContextLimit(modelId);
+    return Math.floor(limit * percent);
+}
+
+/**
+ * Register a custom model context limit at runtime.
+ * Useful for models launched after deployment.
+ */
+export function registerModelContextLimit(modelId: string, contextTokens: number): void {
+    MODEL_CONTEXT_LIMITS[modelId] = contextTokens;
+    logger.info('Custom model context limit registered', { modelId, contextTokens });
+}
+
+/**
+ * Get all registered model IDs and their limits (for diagnostics).
+ */
+export function listModelContextLimits(): Record<string, number> {
+    return { ...MODEL_CONTEXT_LIMITS };
+}

package/src/config/PromptCompactionConfig.ts

@@ -0,0 +1,236 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+
+/**
+ * Prompt Auto-Compaction Configuration
+ *
+ * Central configuration for all prompt compaction features.
+ * All features are DISABLED by default for safe rollout.
+ */
+
+import { Logger } from '../utils/Logger.js';
+
+const logger = new Logger('info', 'PromptCompactionConfig', 'server');
+
+/**
+ * Prompt compaction configuration interface
+ */
+export interface PromptCompactionConfig {
+    // Master switches
+    enabled: boolean;
+    residualsEnabled: boolean;
+    tieredEnabled: boolean;
+    budgetEnabled: boolean;
+
+    // Residual detection settings
+    residualThreshold: number;
+    residualMaxPercent: number;
+
+    // Tiered compression settings
+    tier0Size: number;
+    tier1Size: number;
+    tier2Size: number;
+
+    // Budget allocation settings
+    defaultTokenBudget: number;
+
+    // System prompt optimization
+    condensedMode: boolean;
+    maxSystemPromptTokens: number;
+
+    // --- Phase 1 feature flags (all default false for safe rollout) ---
+
+    /** Enable tool result microcompaction (cheap, no LLM — strips old tool result bodies) */
+    microcompactionEnabled: boolean;
+    /** Token count above which microcompaction triggers */
+    microcompactionTokenThreshold: number;
+
+    /** Enable percentage-based compaction thresholds instead of fixed window size */
+    percentageCompactionEnabled: boolean;
+    /** Context usage percentage at which auto-compaction triggers (0.0–1.0) */
+    compactionThresholdPercent: number;
+
+    /** Enable structured summary format for compacted conversations */
+    structuredSummariesEnabled: boolean;
+
+    /** Enable post-compaction artifact restoration (task state, ORPAR phase, etc.) */
+    postCompactionRestorationEnabled: boolean;
+
+    /** Enable reactive compaction for 413 context overflow recovery */
+    reactiveCompactionEnabled: boolean;
+
+    /** Enable mid-conversation system reminders */
+    systemRemindersEnabled: boolean;
+    /** Max total tokens for system reminders per LLM request */
+    systemReminderTokenBudget: number;
+
+    /** Enable tool-specific behavioral guidance in tool descriptions */
+    toolBehavioralGuidanceEnabled: boolean;
+
+    /** Enable progressive tool schema disclosure (tier-1 full / tier-2 deferred) */
+    deferredToolSchemasEnabled: boolean;
+
+    /** Enable dynamic context injection (task progress, errors, channel state) */
+    dynamicContextInjectionEnabled: boolean;
+    /** Max tokens for dynamic context injection */
+    dynamicContextTokenBudget: number;
+}
+
+/**
+ * Load configuration from environment variables
+ */
+export function loadPromptCompactionConfig(): PromptCompactionConfig {
+    const config: PromptCompactionConfig = {
+        // Master switches (all default to false for safe rollout)
+        enabled: process.env.PROMPT_COMPACTION_ENABLED === 'true',
+        residualsEnabled: process.env.PROMPT_COMPACTION_RESIDUALS_ENABLED === 'true',
+        tieredEnabled: process.env.PROMPT_COMPACTION_TIERED_ENABLED === 'true',
+        budgetEnabled: process.env.PROMPT_COMPACTION_BUDGET_ENABLED === 'true',
+
+        // Residual detection (skip connections)
+        residualThreshold: parseInt(process.env.PROMPT_COMPACTION_RESIDUAL_THRESHOLD || '60'),
+        residualMaxPercent: parseFloat(process.env.PROMPT_COMPACTION_RESIDUAL_MAX_PERCENT || '0.20'),
+
+        // Tiered compression (ResNet-inspired hierarchy)
+        tier0Size: parseInt(process.env.PROMPT_COMPACTION_TIER0_SIZE || '10'),
+        tier1Size: parseInt(process.env.PROMPT_COMPACTION_TIER1_SIZE || '25'),
+        tier2Size: parseInt(process.env.PROMPT_COMPACTION_TIER2_SIZE || '50'),
+
+        // Token budget allocation
+        defaultTokenBudget: parseInt(process.env.PROMPT_COMPACTION_DEFAULT_BUDGET || '8000'),
+
+        // System prompt optimization
+        condensedMode: process.env.PROMPT_COMPACTION_CONDENSED_MODE === 'true',
+        maxSystemPromptTokens: parseInt(process.env.PROMPT_COMPACTION_MAX_SYSTEM_PROMPT_TOKENS || '2500'),
+
+        // Phase 1 feature flags (all default false)
+        microcompactionEnabled: process.env.MICROCOMPACTION_ENABLED === 'true',
+        microcompactionTokenThreshold: parseInt(process.env.MICROCOMPACTION_TOKEN_THRESHOLD || '50000'),
+
+        percentageCompactionEnabled: process.env.PERCENTAGE_COMPACTION_ENABLED === 'true',
+        compactionThresholdPercent: parseFloat(process.env.COMPACTION_THRESHOLD_PERCENT || '0.80'),
+
+        structuredSummariesEnabled: process.env.STRUCTURED_SUMMARIES_ENABLED === 'true',
+        postCompactionRestorationEnabled: process.env.POST_COMPACTION_RESTORATION_ENABLED === 'true',
+        reactiveCompactionEnabled: process.env.REACTIVE_COMPACTION_ENABLED === 'true',
+
+        systemRemindersEnabled: process.env.SYSTEM_REMINDERS_ENABLED === 'true',
+        systemReminderTokenBudget: parseInt(process.env.SYSTEM_REMINDER_TOKEN_BUDGET || '500'),
+
+        toolBehavioralGuidanceEnabled: process.env.TOOL_BEHAVIORAL_GUIDANCE_ENABLED === 'true',
+        deferredToolSchemasEnabled: process.env.DEFERRED_TOOL_SCHEMAS_ENABLED === 'true',
+
+        dynamicContextInjectionEnabled: process.env.DYNAMIC_CONTEXT_INJECTION_ENABLED === 'true',
+        dynamicContextTokenBudget: parseInt(process.env.DYNAMIC_CONTEXT_TOKEN_BUDGET || '1000'),
+    };
+
+    logger.info('Prompt compaction configuration loaded', config);
+
+    return config;
+}
+
+/**
+ * Validate configuration values
+ */
+export function validatePromptCompactionConfig(config: PromptCompactionConfig): string[] {
+    const errors: string[] = [];
+
+    // Validate residual threshold (0-100)
+    if (config.residualThreshold < 0 || config.residualThreshold > 100) {
+        errors.push('Residual threshold must be between 0 and 100');
+    }
+
+    // Validate residual max percent (0.0-1.0)
+    if (config.residualMaxPercent < 0 || config.residualMaxPercent > 1.0) {
+        errors.push('Residual max percent must be between 0.0 and 1.0');
+    }
+
+    // Validate tier sizes (must be increasing)
+    if (config.tier0Size >= config.tier1Size) {
+        errors.push('Tier 1 size must be greater than Tier 0 size');
+    }
+    if (config.tier1Size >= config.tier2Size) {
+        errors.push('Tier 2 size must be greater than Tier 1 size');
+    }
+
+    // Validate token budget (positive)
+    if (config.defaultTokenBudget <= 0) {
+        errors.push('Default token budget must be positive');
+    }
+
+    // Validate max system prompt tokens
+    if (config.maxSystemPromptTokens <= 0) {
+        errors.push('Max system prompt tokens must be positive');
+    }
+
+    // Validate Phase 1 settings
+    if (config.microcompactionTokenThreshold <= 0) {
+        errors.push('Microcompaction token threshold must be positive');
+    }
+    if (config.compactionThresholdPercent < 0 || config.compactionThresholdPercent > 1.0) {
+        errors.push('Compaction threshold percent must be between 0.0 and 1.0');
+    }
+    if (config.systemReminderTokenBudget <= 0) {
+        errors.push('System reminder token budget must be positive');
+    }
+    if (config.dynamicContextTokenBudget <= 0) {
+        errors.push('Dynamic context token budget must be positive');
+    }
+
+    if (errors.length > 0) {
+        logger.error('Prompt compaction configuration validation failed', { errors });
+    }
+
+    return errors;
+}
+
+/**
+ * Get default configuration (all features disabled)
+ */
+export function getDefaultPromptCompactionConfig(): PromptCompactionConfig {
+    return {
+        enabled: false,
+        residualsEnabled: false,
+        tieredEnabled: false,
+        budgetEnabled: false,
+        residualThreshold: 60,
+        residualMaxPercent: 0.20,
+        tier0Size: 10,
+        tier1Size: 25,
+        tier2Size: 50,
+        defaultTokenBudget: 8000,
+        condensedMode: false,
+        maxSystemPromptTokens: 2500,
+
+        microcompactionEnabled: false,
+        microcompactionTokenThreshold: 50000,
+        percentageCompactionEnabled: false,
+        compactionThresholdPercent: 0.80,
+        structuredSummariesEnabled: false,
+        postCompactionRestorationEnabled: false,
+        reactiveCompactionEnabled: false,
+        systemRemindersEnabled: false,
+        systemReminderTokenBudget: 500,
+        toolBehavioralGuidanceEnabled: false,
+        deferredToolSchemasEnabled: false,
+        dynamicContextInjectionEnabled: false,
+        dynamicContextTokenBudget: 1000,
+    };
+}