comisai 1.0.4

package/node_modules/@comis/core/dist/config/include-resolver.js

@@ -0,0 +1,130 @@
+import { ok, err } from "@comis/shared";
+import * as path from "node:path";
+import { deepMerge } from "./layered.js";
+/**
+ * Maximum nesting depth for $include directives.
+ * Prevents runaway recursion from deeply-nested (but non-circular) include chains.
+ */
+export const MAX_INCLUDE_DEPTH = 10;
+/**
+ * Resolve all `$include` directives in a parsed config object tree.
+ *
+ * Processing rules:
+ * - Walks the object tree recursively looking for `$include` string keys
+ * - For each `$include`, loads and parses the referenced file
+ * - Deep merges: included content is the base, sibling keys override
+ * - Detects circular references via a visited path set
+ * - Enforces a maximum nesting depth of MAX_INCLUDE_DEPTH
+ * - Include paths are resolved via deps.resolvePath (safePath in production)
+ *
+ * @param obj - The parsed config object (or any value from the tree)
+ * @param basePath - Directory to resolve relative include paths against
+ * @param deps - Injectable file I/O and path resolution
+ * @param visited - Set of already-visited absolute paths (for circular detection)
+ * @param depth - Current nesting depth (0-based)
+ * @returns The resolved object with all $include directives expanded
+ */
+export function resolveIncludes(obj, basePath, deps, visited, depth) {
+    const currentDepth = depth ?? 0;
+    const visitedSet = visited ?? new Set();
+    // Non-object values pass through unchanged
+    if (obj === null || obj === undefined || typeof obj !== "object") {
+        return ok(obj);
+    }
+    // Arrays: resolve each element recursively
+    if (Array.isArray(obj)) {
+        const resolved = [];
+        for (const element of obj) {
+            const result = resolveIncludes(element, basePath, deps, visitedSet, currentDepth);
+            if (!result.ok) {
+                return result;
+            }
+            resolved.push(result.value);
+        }
+        return ok(resolved);
+    }
+    // Plain object: check for $include directive
+    const record = obj;
+    if ("$include" in record && typeof record.$include === "string") {
+        // Check depth limit
+        if (currentDepth >= MAX_INCLUDE_DEPTH) {
+            return err({
+                code: "INCLUDE_ERROR",
+                message: `Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded — check for deep nesting`,
+            });
+        }
+        const includePath = record.$include;
+        // Resolve the include path against the base directory
+        const resolveResult = deps.resolvePath(basePath, includePath);
+        if (!resolveResult.ok) {
+            return err({
+                code: "INCLUDE_ERROR",
+                message: resolveResult.error.message,
+                path: includePath,
+            });
+        }
+        const absPath = path.normalize(resolveResult.value);
+        // Check for circular includes
+        if (visitedSet.has(absPath)) {
+            const cycle = [...visitedSet, absPath].join(" -> ");
+            return err({
+                code: "CIRCULAR_INCLUDE",
+                message: `Circular $include detected: ${cycle}`,
+                path: absPath,
+            });
+        }
+        // Add to visited set
+        const newVisited = new Set(visitedSet);
+        newVisited.add(absPath);
+        // Read the included file
+        const readResult = deps.readFile(absPath);
+        if (!readResult.ok) {
+            return err({
+                code: "INCLUDE_ERROR",
+                message: `Failed to read included file "${includePath}": ${readResult.error.message}`,
+                path: absPath,
+            });
+        }
+        // Parse the included file
+        const parseResult = deps.parseFn(readResult.value, absPath);
+        if (!parseResult.ok) {
+            return err({
+                code: "INCLUDE_ERROR",
+                message: `Failed to parse included file "${includePath}": ${parseResult.error.message}`,
+                path: absPath,
+            });
+        }
+        // Recursively resolve includes in the included content
+        const includedBasePath = path.dirname(absPath);
+        const resolvedIncluded = resolveIncludes(parseResult.value, includedBasePath, deps, newVisited, currentDepth + 1);
+        if (!resolvedIncluded.ok) {
+            return resolvedIncluded;
+        }
+        // Build the sibling object (everything except $include)
+        const siblings = {};
+        for (const key of Object.keys(record)) {
+            if (key !== "$include") {
+                siblings[key] = record[key];
+            }
+        }
+        // Resolve includes in sibling values too
+        const resolvedSiblings = resolveIncludes(siblings, basePath, deps, visitedSet, currentDepth);
+        if (!resolvedSiblings.ok) {
+            return resolvedSiblings;
+        }
+        // Deep merge: included content is the base, siblings override
+        const included = resolvedIncluded.value;
+        const overrides = resolvedSiblings.value;
+        return ok(deepMerge(included, overrides));
+    }
+    // No $include at this level — recurse into all values
+    const result = {};
+    for (const key of Object.keys(record)) {
+        const resolved = resolveIncludes(record[key], basePath, deps, visitedSet, currentDepth);
+        if (!resolved.ok) {
+            return resolved;
+        }
+        result[key] = resolved.value;
+    }
+    return ok(result);
+}

package/node_modules/@comis/core/dist/config/include-resolver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@comis/core/dist/config/include-resolver.test.js

@@ -0,0 +1,292 @@
+import { describe, it, expect } from "vitest";
+import { ok, err } from "@comis/shared";
+import { resolveIncludes } from "./include-resolver.js";
+/**
+ * Helper to create mock deps with a virtual filesystem.
+ * Files are keyed by absolute path, values are raw YAML/JSON strings.
+ */
+function createMockDeps(files) {
+    return {
+        readFile(absPath) {
+            if (absPath in files) {
+                return ok(files[absPath]);
+            }
+            return err({
+                code: "FILE_NOT_FOUND",
+                message: `File not found: ${absPath}`,
+                path: absPath,
+            });
+        },
+        parseFn(raw, _filePath) {
+            try {
+                // Simple JSON parse for tests (YAML is a superset of JSON)
+                const parsed = JSON.parse(raw);
+                if (parsed === null || parsed === undefined) {
+                    return ok({});
+                }
+                if (typeof parsed !== "object" || Array.isArray(parsed)) {
+                    return err({
+                        code: "PARSE_ERROR",
+                        message: `Expected object, got ${typeof parsed}`,
+                    });
+                }
+                return ok(parsed);
+            }
+            catch (e) {
+                return err({
+                    code: "PARSE_ERROR",
+                    message: `Parse error: ${e.message}`,
+                });
+            }
+        },
+        resolvePath(basePath, includePath) {
+            // Simple path join for tests — in production this uses safePath()
+            // Reject traversal attempts in tests too
+            if (includePath.includes("..")) {
+                return err({
+                    code: "INCLUDE_ERROR",
+                    message: `Path traversal blocked: "${includePath}" escapes base "${basePath}"`,
+                    path: includePath,
+                });
+            }
+            const resolved = basePath + "/" + includePath;
+            return ok(resolved);
+        },
+    };
+}
+describe("config/include-resolver", () => {
+    describe("resolveIncludes", () => {
+        it("resolves simple $include and deep-merges included content", () => {
+            const deps = createMockDeps({
+                "/config/base.json": JSON.stringify({
+                    logLevel: "debug",
+                    agents: { default: { name: "BaseBot" } },
+                }),
+            });
+            const obj = {
+                $include: "base.json",
+                tenantId: "my-tenant",
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                // Included content is base, sibling keys override
+                expect(val.logLevel).toBe("debug");
+                expect(val.tenantId).toBe("my-tenant");
+                const agents = val.agents;
+                expect(agents.default.name).toBe("BaseBot");
+                // $include key should be removed
+                expect(val.$include).toBeUndefined();
+            }
+        });
+        it("resolves nested includes (included file includes another file)", () => {
+            const deps = createMockDeps({
+                "/config/a.json": JSON.stringify({
+                    $include: "b.json",
+                    fromA: true,
+                }),
+                "/config/b.json": JSON.stringify({
+                    fromB: true,
+                    shared: "from-b",
+                }),
+            });
+            const obj = {
+                $include: "a.json",
+                topLevel: "value",
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                expect(val.fromB).toBe(true);
+                expect(val.fromA).toBe(true);
+                expect(val.topLevel).toBe("value");
+            }
+        });
+        it("detects circular reference: A includes B includes A", () => {
+            const deps = createMockDeps({
+                "/config/a.json": JSON.stringify({ $include: "b.json" }),
+                "/config/b.json": JSON.stringify({ $include: "a.json" }),
+            });
+            const obj = { $include: "a.json" };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error.code).toBe("CIRCULAR_INCLUDE");
+                expect(result.error.message).toContain("Circular");
+            }
+        });
+        it("returns INCLUDE_ERROR when depth limit (MAX_INCLUDE_DEPTH = 10) is exceeded", () => {
+            // Create a chain of 12 files, each including the next
+            const files = {};
+            for (let i = 0; i < 12; i++) {
+                files[`/config/f${i}.json`] = JSON.stringify({
+                    $include: `f${i + 1}.json`,
+                    [`key${i}`]: i,
+                });
+            }
+            files["/config/f12.json"] = JSON.stringify({ leaf: true });
+            const deps = createMockDeps(files);
+            const obj = { $include: "f0.json" };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error.code).toBe("INCLUDE_ERROR");
+                expect(result.error.message).toContain("depth");
+            }
+        });
+        it("rejects include path traversal attempt via resolvePath", () => {
+            const deps = createMockDeps({});
+            const obj = { $include: "../../../etc/passwd" };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error.code).toBe("INCLUDE_ERROR");
+                expect(result.error.message).toContain("traversal");
+            }
+        });
+        it("returns INCLUDE_ERROR for non-existent included file", () => {
+            const deps = createMockDeps({});
+            const obj = { $include: "missing.json" };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error.code).toBe("INCLUDE_ERROR");
+                expect(result.error.message).toContain("missing.json");
+            }
+        });
+        it("deep-merges sibling keys alongside $include (siblings override included content)", () => {
+            const deps = createMockDeps({
+                "/config/base.json": JSON.stringify({
+                    agents: { default: { name: "Base", model: "gpt-4" } },
+                    logLevel: "info",
+                }),
+            });
+            const obj = {
+                $include: "base.json",
+                agents: { default: { name: "Override" } },
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                const agents = val.agents;
+                // Sibling overrides included
+                expect(agents.default.name).toBe("Override");
+                // Included fields preserved where not overridden
+                expect(agents.default.model).toBe("gpt-4");
+                expect(val.logLevel).toBe("info");
+            }
+        });
+        it("resolves $include at nested object levels (not just top-level)", () => {
+            const deps = createMockDeps({
+                "/config/memory-defaults.json": JSON.stringify({
+                    walMode: true,
+                    compaction: { enabled: true, threshold: 500 },
+                }),
+            });
+            const obj = {
+                tenantId: "test",
+                memory: {
+                    $include: "memory-defaults.json",
+                    dbPath: "/custom/path.db",
+                },
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                expect(val.tenantId).toBe("test");
+                const memory = val.memory;
+                expect(memory.walMode).toBe(true);
+                expect(memory.dbPath).toBe("/custom/path.db");
+                const compaction = memory.compaction;
+                expect(compaction.enabled).toBe(true);
+                expect(compaction.threshold).toBe(500);
+            }
+        });
+        it("resolves multiple $include directives across different nested paths", () => {
+            const deps = createMockDeps({
+                "/config/agent-defaults.json": JSON.stringify({
+                    name: "DefaultAgent",
+                    model: "gpt-4",
+                }),
+                "/config/memory-defaults.json": JSON.stringify({
+                    walMode: true,
+                    embeddingModel: "text-embedding-3-small",
+                }),
+            });
+            const obj = {
+                tenantId: "multi",
+                agents: {
+                    default: {
+                        $include: "agent-defaults.json",
+                        maxSteps: 25,
+                    },
+                },
+                memory: {
+                    $include: "memory-defaults.json",
+                    dbPath: "/var/db.sqlite",
+                },
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                expect(val.tenantId).toBe("multi");
+                const agents = val.agents;
+                expect(agents.default.name).toBe("DefaultAgent");
+                expect(agents.default.model).toBe("gpt-4");
+                expect(agents.default.maxSteps).toBe(25);
+                const memory = val.memory;
+                expect(memory.walMode).toBe(true);
+                expect(memory.embeddingModel).toBe("text-embedding-3-small");
+                expect(memory.dbPath).toBe("/var/db.sqlite");
+            }
+        });
+        it("passes through non-object values unchanged", () => {
+            const deps = createMockDeps({});
+            // Primitives and arrays should pass through
+            const result1 = resolveIncludes("hello", "/config", deps);
+            expect(result1.ok).toBe(true);
+            if (result1.ok) {
+                expect(result1.value).toBe("hello");
+            }
+            const result2 = resolveIncludes(42, "/config", deps);
+            expect(result2.ok).toBe(true);
+            if (result2.ok) {
+                expect(result2.value).toBe(42);
+            }
+            const result3 = resolveIncludes([1, 2, 3], "/config", deps);
+            expect(result3.ok).toBe(true);
+            if (result3.ok) {
+                expect(result3.value).toEqual([1, 2, 3]);
+            }
+        });
+        it("resolves $include in array elements that are objects", () => {
+            const deps = createMockDeps({
+                "/config/item.json": JSON.stringify({
+                    name: "from-include",
+                    value: 42,
+                }),
+            });
+            const obj = {
+                items: [
+                    { $include: "item.json", extra: "data" },
+                    { plain: "object" },
+                ],
+            };
+            const result = resolveIncludes(obj, "/config", deps);
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                const val = result.value;
+                const items = val.items;
+                expect(items[0].name).toBe("from-include");
+                expect(items[0].value).toBe(42);
+                expect(items[0].extra).toBe("data");
+                expect(items[1].plain).toBe("object");
+            }
+        });
+    });
+});

package/node_modules/@comis/core/dist/config/index.d.ts

@@ -0,0 +1,76 @@
+export { AppConfigSchema } from "./schema.js";
+export { ApprovalsConfigSchema, ApprovalRuleSchema, checkApprovalsConfig } from "./schema-approvals.js";
+export { AutoReplyEngineConfigSchema, GroupActivationModeSchema, } from "./schema-auto-reply-engine.js";
+export { BrowserConfigSchema } from "./schema-browser.js";
+export { MessagesConfigSchema } from "./schema-messages.js";
+export { ModelsConfigSchema, ModelAliasSchema } from "./schema-models.js";
+export { ProvidersConfigSchema, ProviderEntrySchema, UserModelSchema, ModelCostSchema } from "./schema-providers.js";
+export { SendPolicyConfigSchema, SendPolicyRuleSchema, SendActionSchema, } from "./schema-send-policy.js";
+export { GeminiCacheConfigSchema } from "./schema-gemini-cache.js";
+export { NotificationConfigSchema } from "./schema-notification.js";
+export type { NotificationConfig } from "./schema-notification.js";
+export { VerbosityConfigSchema, VerbosityLevelSchema, VerbosityOverrideSchema } from "./schema-verbosity.js";
+export type { VerbosityConfig, VerbosityLevel, VerbosityOverride } from "./schema-verbosity.js";
+export { MemoryReviewConfigSchema } from "./schema-memory-review.js";
+export type { MemoryReviewConfig } from "./schema-memory-review.js";
+export { AgentConfigSchema, AgentsMapSchema, AuthProfileSchema, BootstrapConfigSchema, BroadcastGroupSchema, BroadcastTargetSchema, BudgetConfigSchema, CircuitBreakerConfigSchema, ToolRetryBreakerConfigSchema, ConcurrencyConfigSchema, ContextEngineConfigSchema, ContextGuardConfigSchema, ContextPruningConfigSchema, DeferredToolsConfigSchema, DmScopeConfigSchema, ElevatedReplyConfigSchema, FallbackModelSchema, HeartbeatTargetSchema, ModelFailoverConfigSchema, ModelRoutesSchema, OperationModelEntrySchema, OperationModelsSchema, PerAgentConfigSchema, PerAgentCronConfigSchema, PerAgentHeartbeatConfigSchema, PerAgentSchedulerConfigSchema, PromptTimeoutConfigSchema, PruningConfigSchema, RagConfigSchema, ResetPolicyOverrideSchema, RoutingBindingSchema, RoutingConfigSchema, SdkRetryConfigSchema, SepConfigSchema, SessionCompactionConfigSchema, SessionResetPolicySchema, SourceGateConfigSchema, ToolLifecycleConfigSchema, TracingConfigSchema, } from "./schema-agent.js";
+export { ChannelConfigSchema, ChannelEntrySchema, AckReactionConfigSchema, MediaProcessingSchema, ChannelHealthCheckSchema, EmailChannelEntrySchema } from "./schema-channel.js";
+export { MemoryConfigSchema, CompactionConfigSchema, RetentionConfigSchema, } from "./schema-memory.js";
+export { SecurityConfigSchema, PermissionConfigSchema, ActionConfirmationConfigSchema, AgentToAgentConfigSchema, } from "./schema-security.js";
+export { SubagentContextConfigSchema } from "../domain/subagent-context-config.js";
+export type { SubagentContextConfig } from "../domain/subagent-context-config.js";
+export { AgentSecretsConfigSchema, SecretsConfigSchema, } from "./schema-secrets.js";
+export { BackgroundTasksConfigSchema } from "./schema-background-tasks.js";
+export type { BackgroundTasksConfig } from "./schema-background-tasks.js";
+export { SkillsConfigSchema, PromptSkillsConfigSchema } from "./schema-skills.js";
+export { DaemonConfigSchema, LoggingConfigSchema, TracingDefaultsSchema, ConfigWebhookSchema } from "./schema-daemon.js";
+export { HeartbeatConfigSchema, SchedulerConfigSchema } from "./schema-scheduler.js";
+export { GatewayConfigSchema, GatewayTlsConfigSchema, GatewayTokenSchema, GatewayRateLimitSchema, } from "./schema-gateway.js";
+export { IntegrationsConfigSchema, BraveSearchConfigSchema, McpServerEntrySchema, McpConfigSchema, TranscriptionConfigSchema, TtsConfigSchema, TtsAutoModeSchema, ElevenLabsVoiceSettingsSchema, TtsOutputFormatSchema, ImageAnalysisConfigSchema, VisionScopeRuleSchema, VisionConfigSchema, LinkUnderstandingConfigSchema, MediaInfraConfigSchema, MediaConfigSchema, AutoReplyRuleSchema, AutoReplyConfigSchema, DOCUMENT_MIME_WHITELIST, FileExtractionConfigSchema, MediaPersistenceConfigSchema, ImageGenerationConfigSchema, } from "./schema-integrations.js";
+export { MonitoringConfigSchema } from "./schema-observability.js";
+export { ObservabilityConfigSchema } from "./schema-observability.js";
+export type { ObservabilityConfig, ObservabilityPersistenceConfig } from "./schema-observability.js";
+export { PluginsConfigSchema, PluginEntrySchema } from "./schema-plugins.js";
+export { QueueConfigSchema, QueueModeSchema, OverflowPolicySchema, PerChannelQueueConfigSchema, OverflowConfigSchema, DebounceBufferConfigSchema, FollowupConfigSchema, PriorityLaneConfigSchema, LaneAssignmentConfigSchema, } from "./schema-queue.js";
+export { StreamingConfigSchema, PerChannelStreamingConfigSchema, TypingModeSchema, ChunkModeSchema, TableModeSchema, } from "./schema-streaming.js";
+export { CoalescerConfigSchema } from "./schema-coalescer.js";
+export { DeliveryMirrorConfigSchema, DeliveryQueueConfigSchema, DeliveryTimingConfigSchema, DeliveryTimingModeSchema } from "./schema-delivery.js";
+export { DocumentationConfigSchema, DocumentationLinkSchema } from "./schema-documentation.js";
+export { EmbeddingConfigSchema } from "./schema-embedding.js";
+export { EnvelopeConfigSchema } from "./schema-envelope.js";
+export { LifecycleReactionsConfigSchema, LifecycleReactionsTimingSchema, LifecycleReactionsPerChannelSchema, } from "./schema-lifecycle-reactions.js";
+export { ResponsePrefixConfigSchema } from "./schema-response-prefix.js";
+export { RetryConfigSchema } from "./schema-retry.js";
+export { SenderTrustDisplayConfigSchema } from "./schema-sender-trust-display.js";
+export { TelegramFileRefGuardConfigSchema } from "./schema-telegram-file-guard.js";
+export { WebhooksConfigSchema, WebhookMappingConfigSchema, WebhookMappingMatchSchema, } from "./schema-webhooks.js";
+export type { AutoReplyEngineConfig, GroupActivationMode, } from "./schema-auto-reply-engine.js";
+export type { CoalescerConfig } from "./schema-coalescer.js";
+export type { DeliveryMirrorConfig, DeliveryQueueConfig, DeliveryTimingConfig, DeliveryTimingMode } from "./schema-delivery.js";
+export type { DocumentationConfig, DocumentationLink } from "./schema-documentation.js";
+export type { SendPolicyConfig, SendPolicyRule, SendAction, } from "./schema-send-policy.js";
+export type { AgentSecretsConfig, SecretsConfig, } from "./schema-secrets.js";
+export type { GeminiCacheConfig } from "./schema-gemini-cache.js";
+export type { AuthProfileEntry, BroadcastGroup, BroadcastTarget, BudgetConfig, CircuitBreakerConfig, ToolRetryBreakerConfig, ConcurrencyConfig, ContextEngineConfig, ContextGuardConfig, ContextPruningConfig, DeferredToolsConfig, DmScopeConfig, ElevatedReplyConfig, FallbackModel, HeartbeatTarget, ModelFailoverConfig, ModelOperationType, ModelRoutes, OperationModelEntry, OperationModels, PerAgentHeartbeatConfig, PromptTimeoutConfig, PruningConfig, ResetPolicyOverride, SdkRetryConfig, SepConfig, SessionCompactionConfig, SessionResetPolicyConfig, SourceGateConfig, ToolLifecycleConfig, TracingConfig, } from "./schema-agent.js";
+export type { AppConfig, AgentConfig, BootstrapConfig, PerAgentConfig, PerAgentCronConfig, PerAgentSchedulerConfig, RagConfig, RoutingBinding, RoutingConfig, ChannelConfig, ChannelEntry, EmailChannelEntry, ChannelHealthCheckConfig, AckReactionConfig, MemoryConfig, CompactionConfig, RetentionConfig, SecurityConfig, PermissionConfig, ActionConfirmationConfig, AgentToAgentConfig, SkillsConfig, PromptSkillsConfig, DaemonConfig, LoggingConfig, TracingDefaults, ConfigWebhook, HeartbeatConfig, SchedulerConfig, GatewayConfig, GatewayTlsConfig, GatewayToken, GatewayRateLimit, IntegrationsConfig, BraveSearchConfig, McpServerEntry, McpConfig, TranscriptionConfig, TtsConfig, TtsAutoMode, ElevenLabsVoiceSettings, TtsOutputFormat, ImageAnalysisConfig, VisionScopeRule, VisionConfig, LinkUnderstandingConfig, MediaConfig, AutoReplyRule, AutoReplyConfig, FileExtractionConfig, MediaPersistenceConfig, ImageGenerationConfig, MonitoringConfig, DiskMonitorConfig, ResourceMonitorConfig, SystemdMonitorConfig, SecurityUpdateMonitorConfig, GitMonitorConfig, PluginsConfig, PluginEntry, QueueConfig, PerChannelQueueConfig, QueueMode, OverflowPolicy, OverflowConfig, DebounceBufferConfig, FollowupConfig, PriorityLaneConfig, LaneAssignmentConfig, StreamingConfig, PerChannelStreamingConfig, TypingMode, ChunkMode, TableMode, EmbeddingConfig, EnvelopeConfig, RetryConfig, WebhooksConfig, WebhookMappingConfig, BrowserConfig, ModelsConfig, ModelAlias, ProvidersConfig, ProviderEntry, UserModel, ModelCost, MessagesConfig, ApprovalsConfig, ApprovalRule, ConfigError, ConfigErrorCode, } from "./types.js";
+export type { LifecycleReactionsConfig, LifecycleReactionsTimingConfig, } from "./schema-lifecycle-reactions.js";
+export type { ResponsePrefixConfig } from "./schema-response-prefix.js";
+export type { SenderTrustDisplayConfig } from "./schema-sender-trust-display.js";
+export type { TelegramFileRefGuardConfig } from "./schema-telegram-file-guard.js";
+export { loadConfigFile, validateConfig } from "./loader.js";
+export type { ConfigLoadOptions } from "./loader.js";
+export { resolveIncludes, MAX_INCLUDE_DEPTH } from "./include-resolver.js";
+export type { IncludeResolverDeps } from "./include-resolver.js";
+export { substituteEnvVars, warnSuspiciousEnvValues, extractReferencedSecretNames, type EnvValueWarning } from "./env-substitution.js";
+export { migrateConfig } from "./migrate.js";
+export { deepMerge, mergeLayered, loadLayered } from "./layered.js";
+export { IMMUTABLE_CONFIG_PREFIXES, MUTABLE_CONFIG_OVERRIDES, isImmutableConfigPath, matchesOverridePattern, getMutableOverridesForSection } from "./immutable-keys.js";
+export { getConfigSchema, getConfigSections } from "./schema-serializer.js";
+export { createTimestampedBackup } from "./backup.js";
+export type { BackupDeps, BackupOptions } from "./backup.js";
+export { validatePartial } from "./partial-validator.js";
+export type { PartialValidationResult } from "./partial-validator.js";
+export { getFieldMetadata } from "./field-metadata.js";
+export type { FieldMetadata } from "./field-metadata.js";
+export { createConfigGitManager, encodeCommitMessage } from "./git-manager.js";
+export type { ConfigGitManager, GitCommitMetadata, HistoryEntry, GitManagerDeps, ExecGitFn, } from "./git-manager.js";

package/node_modules/@comis/core/dist/config/index.js

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+// @comis/core/config — Layered configuration with Zod validation
+// Schemas (for direct validation or extension)
+export { AppConfigSchema } from "./schema.js";
+export { ApprovalsConfigSchema, ApprovalRuleSchema, checkApprovalsConfig } from "./schema-approvals.js";
+export { AutoReplyEngineConfigSchema, GroupActivationModeSchema, } from "./schema-auto-reply-engine.js";
+export { BrowserConfigSchema } from "./schema-browser.js";
+export { MessagesConfigSchema } from "./schema-messages.js";
+export { ModelsConfigSchema, ModelAliasSchema } from "./schema-models.js";
+export { ProvidersConfigSchema, ProviderEntrySchema, UserModelSchema, ModelCostSchema } from "./schema-providers.js";
+export { SendPolicyConfigSchema, SendPolicyRuleSchema, SendActionSchema, } from "./schema-send-policy.js";
+// Gemini cache schema (CachedContent lifecycle)
+export { GeminiCacheConfigSchema } from "./schema-gemini-cache.js";
+// Notification schema
+export { NotificationConfigSchema } from "./schema-notification.js";
+// Verbosity schema
+export { VerbosityConfigSchema, VerbosityLevelSchema, VerbosityOverrideSchema } from "./schema-verbosity.js";
+// Memory review schema
+export { MemoryReviewConfigSchema } from "./schema-memory-review.js";
+// Agent schemas: model selection, session lifecycle, context engine, context guard, agent features
+export { AgentConfigSchema, AgentsMapSchema, AuthProfileSchema, BootstrapConfigSchema, BroadcastGroupSchema, BroadcastTargetSchema, BudgetConfigSchema, CircuitBreakerConfigSchema, ToolRetryBreakerConfigSchema, ConcurrencyConfigSchema, ContextEngineConfigSchema, ContextGuardConfigSchema, ContextPruningConfigSchema, DeferredToolsConfigSchema, DmScopeConfigSchema, ElevatedReplyConfigSchema, FallbackModelSchema, HeartbeatTargetSchema, ModelFailoverConfigSchema, ModelRoutesSchema, OperationModelEntrySchema, OperationModelsSchema, PerAgentConfigSchema, PerAgentCronConfigSchema, PerAgentHeartbeatConfigSchema, PerAgentSchedulerConfigSchema, PromptTimeoutConfigSchema, PruningConfigSchema, RagConfigSchema, ResetPolicyOverrideSchema, RoutingBindingSchema, RoutingConfigSchema, SdkRetryConfigSchema, SepConfigSchema, SessionCompactionConfigSchema, SessionResetPolicySchema, SourceGateConfigSchema, ToolLifecycleConfigSchema, TracingConfigSchema, } from "./schema-agent.js";
+export { ChannelConfigSchema, ChannelEntrySchema, AckReactionConfigSchema, MediaProcessingSchema, ChannelHealthCheckSchema, EmailChannelEntrySchema } from "./schema-channel.js";
+export { MemoryConfigSchema, CompactionConfigSchema, RetentionConfigSchema, } from "./schema-memory.js";
+export { SecurityConfigSchema, PermissionConfigSchema, ActionConfirmationConfigSchema, AgentToAgentConfigSchema, } from "./schema-security.js";
+export { SubagentContextConfigSchema } from "../domain/subagent-context-config.js";
+export { AgentSecretsConfigSchema, SecretsConfigSchema, } from "./schema-secrets.js";
+export { BackgroundTasksConfigSchema } from "./schema-background-tasks.js";
+export { SkillsConfigSchema, PromptSkillsConfigSchema } from "./schema-skills.js";
+export { DaemonConfigSchema, LoggingConfigSchema, TracingDefaultsSchema, ConfigWebhookSchema } from "./schema-daemon.js";
+export { HeartbeatConfigSchema, SchedulerConfigSchema } from "./schema-scheduler.js";
+export { GatewayConfigSchema, GatewayTlsConfigSchema, GatewayTokenSchema, GatewayRateLimitSchema, } from "./schema-gateway.js";
+export { IntegrationsConfigSchema, BraveSearchConfigSchema, McpServerEntrySchema, McpConfigSchema, TranscriptionConfigSchema, TtsConfigSchema, TtsAutoModeSchema, ElevenLabsVoiceSettingsSchema, TtsOutputFormatSchema, ImageAnalysisConfigSchema, VisionScopeRuleSchema, VisionConfigSchema, LinkUnderstandingConfigSchema, MediaInfraConfigSchema, MediaConfigSchema, AutoReplyRuleSchema, AutoReplyConfigSchema, DOCUMENT_MIME_WHITELIST, FileExtractionConfigSchema, MediaPersistenceConfigSchema, ImageGenerationConfigSchema, } from "./schema-integrations.js";
+export { MonitoringConfigSchema } from "./schema-observability.js";
+export { ObservabilityConfigSchema } from "./schema-observability.js";
+export { PluginsConfigSchema, PluginEntrySchema } from "./schema-plugins.js";
+export { QueueConfigSchema, QueueModeSchema, OverflowPolicySchema, PerChannelQueueConfigSchema, OverflowConfigSchema, DebounceBufferConfigSchema, FollowupConfigSchema, PriorityLaneConfigSchema, LaneAssignmentConfigSchema, } from "./schema-queue.js";
+export { StreamingConfigSchema, PerChannelStreamingConfigSchema, TypingModeSchema, ChunkModeSchema, TableModeSchema, } from "./schema-streaming.js";
+export { CoalescerConfigSchema } from "./schema-coalescer.js";
+export { DeliveryMirrorConfigSchema, DeliveryQueueConfigSchema, DeliveryTimingConfigSchema, DeliveryTimingModeSchema } from "./schema-delivery.js";
+export { DocumentationConfigSchema, DocumentationLinkSchema } from "./schema-documentation.js";
+export { EmbeddingConfigSchema } from "./schema-embedding.js";
+export { EnvelopeConfigSchema } from "./schema-envelope.js";
+export { LifecycleReactionsConfigSchema, LifecycleReactionsTimingSchema, LifecycleReactionsPerChannelSchema, } from "./schema-lifecycle-reactions.js";
+export { ResponsePrefixConfigSchema } from "./schema-response-prefix.js";
+export { RetryConfigSchema } from "./schema-retry.js";
+export { SenderTrustDisplayConfigSchema } from "./schema-sender-trust-display.js";
+export { TelegramFileRefGuardConfigSchema } from "./schema-telegram-file-guard.js";
+export { WebhooksConfigSchema, WebhookMappingConfigSchema, WebhookMappingMatchSchema, } from "./schema-webhooks.js";
+// Loader (file loading + validation)
+export { loadConfigFile, validateConfig } from "./loader.js";
+// Include resolver ($include directive processing)
+export { resolveIncludes, MAX_INCLUDE_DEPTH } from "./include-resolver.js";
+// Environment variable substitution (${VAR} processing)
+export { substituteEnvVars, warnSuspiciousEnvValues, extractReferencedSecretNames } from "./env-substitution.js";
+// Config migration (legacy key transformation)
+export { migrateConfig } from "./migrate.js";
+// Layered merge
+export { deepMerge, mergeLayered, loadLayered } from "./layered.js";
+// Immutable key guard (runtime config mutation protection)
+export { IMMUTABLE_CONFIG_PREFIXES, MUTABLE_CONFIG_OVERRIDES, isImmutableConfigPath, matchesOverridePattern, getMutableOverridesForSection } from "./immutable-keys.js";
+// Schema serializer (Zod to JSON Schema conversion)
+export { getConfigSchema, getConfigSections } from "./schema-serializer.js";
+// Config backup (timestamped backup creation with rotation)
+export { createTimestampedBackup } from "./backup.js";
+// Partial validator (section-by-section validation)
+export { validatePartial } from "./partial-validator.js";
+// Field metadata (config field introspection for CLI/UI)
+export { getFieldMetadata } from "./field-metadata.js";
+// Git-backed config versioning (init, commit, history, diff, rollback)
+export { createConfigGitManager, encodeCommitMessage } from "./git-manager.js";

package/node_modules/@comis/core/dist/config/layered.d.ts

@@ -0,0 +1,30 @@
+import type { Result } from "@comis/shared";
+import type { AppConfig, ConfigError } from "./types.js";
+/**
+ * Deep merge two objects with layered override semantics.
+ *
+ * Rules:
+ * - Objects: recursive merge
+ * - Arrays: later layer replaces entirely (no concatenation)
+ * - Primitives: later layer overrides
+ * - undefined values: ignored (don't overwrite existing)
+ */
+export declare function deepMerge(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Merge multiple raw config layers and validate the result.
+ *
+ * Layers are applied left-to-right: later layers override earlier ones.
+ * The merged result is validated against AppConfigSchema.
+ */
+export declare function mergeLayered(layers: Record<string, unknown>[]): Result<AppConfig, ConfigError>;
+/**
+ * Load config files from multiple paths and merge them in order.
+ *
+ * Files are loaded left-to-right with later files overriding earlier ones.
+ * This supports the common pattern: defaults.yaml < config.yaml < config.local.yaml
+ *
+ * If any file fails to load, returns the error immediately.
+ */
+export declare function loadLayered(configPaths: string[], options?: {
+    getSecret?: (key: string) => string | undefined;
+}): Result<AppConfig, ConfigError>;