comisai 1.0.36 → 1.0.40

package/node_modules/@comis/core/dist/config/schema-queue.d.ts

@@ -8,11 +8,8 @@ import { z } from "zod";
  * during execution.
  */
 export declare const DebounceBufferConfigSchema: z.ZodObject<{
-    /** Per-channel debounce window in milliseconds. 0 = disabled. */
     windowMs: z.ZodDefault<z.ZodNumber>;
-    /** Maximum messages to buffer per session before forced flush */
     maxBufferedMessages: z.ZodDefault<z.ZodNumber>;
-    /** First message in burst triggers immediately (skip debounce) */
     firstMessageImmediate: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type DebounceBufferConfig = z.infer<typeof DebounceBufferConfigSchema>;
@@ -46,9 +43,7 @@ export declare const OverflowPolicySchema: z.ZodDefault<z.ZodEnum<{
  * Overflow prevention configuration for a queue lane.
  */
 export declare const OverflowConfigSchema: z.ZodObject<{
-    /** Maximum queued messages per session before overflow triggers */
     maxDepth: z.ZodDefault<z.ZodNumber>;
-    /** What to do when maxDepth is reached */
     policy: z.ZodDefault<z.ZodEnum<{
         "drop-old": "drop-old";
         "drop-new": "drop-new";
@@ -62,25 +57,20 @@ export declare const OverflowConfigSchema: z.ZodObject<{
  * queue modes and overflow policies.
  */
 export declare const PerChannelQueueConfigSchema: z.ZodObject<{
-    /** How rapid messages during active execution are handled */
     mode: z.ZodDefault<z.ZodEnum<{
         followup: "followup";
         collect: "collect";
         steer: "steer";
         "steer+followup": "steer+followup";
     }>>;
-    /** Overflow prevention settings */
     overflow: z.ZodDefault<z.ZodObject<{
-        /** Maximum queued messages per session before overflow triggers */
         maxDepth: z.ZodDefault<z.ZodNumber>;
-        /** What to do when maxDepth is reached */
         policy: z.ZodDefault<z.ZodEnum<{
             "drop-old": "drop-old";
             "drop-new": "drop-new";
             summarize: "summarize";
         }>>;
     }, z.core.$strict>>;
-    /** Debounce delay in ms (0 = disabled). Waits this long after last message before processing. */
     debounceMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 /**
@@ -90,9 +80,7 @@ export declare const PerChannelQueueConfigSchema: z.ZodObject<{
  * without external intervention.
  */
 export declare const FollowupConfigSchema: z.ZodObject<{
-    /** Maximum follow-up runs in a single chain (prevents infinite loops) */
     maxFollowupRuns: z.ZodDefault<z.ZodNumber>;
-    /** Whether to trigger follow-up on compaction flush events */
     followupOnCompaction: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type FollowupConfig = z.infer<typeof FollowupConfigSchema>;
@@ -104,13 +92,9 @@ export type FollowupConfig = z.infer<typeof FollowupConfigSchema>;
  * different scheduling priorities.
  */
 export declare const PriorityLaneConfigSchema: z.ZodObject<{
-    /** Lane name (e.g., "high", "normal", "low") */
     name: z.ZodString;
-    /** Concurrency limit for this lane */
     concurrency: z.ZodDefault<z.ZodNumber>;
-    /** Scheduling priority (higher number = higher priority) */
     priority: z.ZodDefault<z.ZodNumber>;
-    /** Age threshold in ms after which tasks emit aging promotion events (0 = disabled) */
     agingPromotionMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export type PriorityLaneConfig = z.infer<typeof PriorityLaneConfigSchema>;
@@ -121,15 +105,10 @@ export type PriorityLaneConfig = z.infer<typeof PriorityLaneConfigSchema>;
  * named priority lanes. The lane names must match entries in priorityLanes.
  */
 export declare const LaneAssignmentConfigSchema: z.ZodObject<{
-    /** Default lane for messages that don't match any rule */
     defaultLane: z.ZodDefault<z.ZodString>;
-    /** Lane for DM messages */
     dmLane: z.ZodDefault<z.ZodString>;
-    /** Lane for group mentions */
     mentionLane: z.ZodDefault<z.ZodString>;
-    /** Lane for follow-up messages */
     followupLane: z.ZodDefault<z.ZodString>;
-    /** Lane for scheduled/background tasks */
     scheduledLane: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
 export type LaneAssignmentConfig = z.infer<typeof LaneAssignmentConfigSchema>;
@@ -140,105 +119,68 @@ export type LaneAssignmentConfig = z.infer<typeof LaneAssignmentConfigSchema>;
  * and caps global concurrency across all sessions.
  */
 export declare const QueueConfigSchema: z.ZodObject<{
-    /** Whether the command queue is enabled */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Maximum concurrent agent executions across all sessions */
     maxConcurrentSessions: z.ZodDefault<z.ZodNumber>;
-    /** Milliseconds before an idle lane is garbage collected (default: 10 minutes) */
     cleanupIdleMs: z.ZodDefault<z.ZodNumber>;
-    /** Default queue mode for channels without per-channel override */
     defaultMode: z.ZodDefault<z.ZodEnum<{
         followup: "followup";
         collect: "collect";
         steer: "steer";
         "steer+followup": "steer+followup";
     }>>;
-    /** Default overflow config for channels without per-channel override */
     defaultOverflow: z.ZodDefault<z.ZodObject<{
-        /** Maximum queued messages per session before overflow triggers */
         maxDepth: z.ZodDefault<z.ZodNumber>;
-        /** What to do when maxDepth is reached */
         policy: z.ZodDefault<z.ZodEnum<{
             "drop-old": "drop-old";
             "drop-new": "drop-new";
             summarize: "summarize";
         }>>;
     }, z.core.$strict>>;
-    /** Default debounce delay in ms for channels without per-channel override */
     defaultDebounceMs: z.ZodDefault<z.ZodNumber>;
-    /** Per-channel-type queue configuration overrides */
     perChannel: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        /** How rapid messages during active execution are handled */
         mode: z.ZodDefault<z.ZodEnum<{
             followup: "followup";
             collect: "collect";
             steer: "steer";
             "steer+followup": "steer+followup";
         }>>;
-        /** Overflow prevention settings */
         overflow: z.ZodDefault<z.ZodObject<{
-            /** Maximum queued messages per session before overflow triggers */
             maxDepth: z.ZodDefault<z.ZodNumber>;
-            /** What to do when maxDepth is reached */
             policy: z.ZodDefault<z.ZodEnum<{
                 "drop-old": "drop-old";
                 "drop-new": "drop-new";
                 summarize: "summarize";
             }>>;
         }, z.core.$strict>>;
-        /** Debounce delay in ms (0 = disabled). Waits this long after last message before processing. */
         debounceMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>>;
-    /** Global debounce buffer configuration (ingress-layer coalescing before queue entry) */
     debounce: z.ZodDefault<z.ZodObject<{
-        /** Per-channel debounce window in milliseconds. 0 = disabled. */
         windowMs: z.ZodDefault<z.ZodNumber>;
-        /** Maximum messages to buffer per session before forced flush */
         maxBufferedMessages: z.ZodDefault<z.ZodNumber>;
-        /** First message in burst triggers immediately (skip debounce) */
         firstMessageImmediate: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Per-channel-type debounce buffer overrides */
     perChannelDebounce: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        /** Per-channel debounce window in milliseconds. 0 = disabled. */
         windowMs: z.ZodDefault<z.ZodNumber>;
-        /** Maximum messages to buffer per session before forced flush */
         maxBufferedMessages: z.ZodDefault<z.ZodNumber>;
-        /** First message in burst triggers immediately (skip debounce) */
         firstMessageImmediate: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>>;
-    /** Follow-up trigger configuration for continuation runs */
     followup: z.ZodDefault<z.ZodObject<{
-        /** Maximum follow-up runs in a single chain (prevents infinite loops) */
         maxFollowupRuns: z.ZodDefault<z.ZodNumber>;
-        /** Whether to trigger follow-up on compaction flush events */
         followupOnCompaction: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Priority lane definitions. Default: high(3), normal(5), low(2) = total concurrency 10 */
     priorityLanes: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        /** Lane name (e.g., "high", "normal", "low") */
         name: z.ZodString;
-        /** Concurrency limit for this lane */
         concurrency: z.ZodDefault<z.ZodNumber>;
-        /** Scheduling priority (higher number = higher priority) */
         priority: z.ZodDefault<z.ZodNumber>;
-        /** Age threshold in ms after which tasks emit aging promotion events (0 = disabled) */
         agingPromotionMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>>;
-    /** Lane assignment rules */
     laneAssignment: z.ZodDefault<z.ZodObject<{
-        /** Default lane for messages that don't match any rule */
         defaultLane: z.ZodDefault<z.ZodString>;
-        /** Lane for DM messages */
         dmLane: z.ZodDefault<z.ZodString>;
-        /** Lane for group mentions */
         mentionLane: z.ZodDefault<z.ZodString>;
-        /** Lane for follow-up messages */
         followupLane: z.ZodDefault<z.ZodString>;
-        /** Lane for scheduled/background tasks */
         scheduledLane: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
-    /** Enable priority lane scheduling (false = single global gate) */
     priorityEnabled: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type QueueConfig = z.infer<typeof QueueConfigSchema>;

package/node_modules/@comis/core/dist/config/schema-response-prefix.d.ts

@@ -9,9 +9,7 @@ import { z } from "zod";
  * Example template: "{agent.emoji} {model|short}{?thinking: | think}"
  */
 export declare const ResponsePrefixConfigSchema: z.ZodObject<{
-    /** Template string for the prefix; empty string disables the feature */
     template: z.ZodDefault<z.ZodString>;
-    /** Where to insert the rendered template relative to the response body */
     position: z.ZodDefault<z.ZodEnum<{
         prepend: "prepend";
         append: "append";

package/node_modules/@comis/core/dist/config/schema-retry.d.ts

@@ -9,17 +9,11 @@ import { z } from "zod";
  * errors, and markdown/HTML parse errors.
  */
 export declare const RetryConfigSchema: z.ZodObject<{
-    /** Maximum retry attempts per message send (default: 3) */
     maxAttempts: z.ZodDefault<z.ZodNumber>;
-    /** Minimum delay in ms before first retry (default: 500) */
     minDelayMs: z.ZodDefault<z.ZodNumber>;
-    /** Maximum delay in ms (cap for exponential backoff, default: 30_000) */
     maxDelayMs: z.ZodDefault<z.ZodNumber>;
-    /** Add random jitter to delay (prevents thundering herd, default: true) */
     jitter: z.ZodDefault<z.ZodBoolean>;
-    /** Respect platform-provided retry_after headers (default: true) */
     respectRetryAfter: z.ZodDefault<z.ZodBoolean>;
-    /** Fall back to plain text on markdown/HTML parse errors (default: true) */
     markdownFallback: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export type RetryConfig = z.infer<typeof RetryConfigSchema>;

package/node_modules/@comis/core/dist/config/schema-scheduler.d.ts

@@ -1,89 +1,50 @@
 import { z } from "zod";
 export declare const HeartbeatConfigSchema: z.ZodObject<{
-    /** Enable periodic heartbeat checks */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Heartbeat interval in milliseconds */
     intervalMs: z.ZodDefault<z.ZodNumber>;
-    /** Show OK status in heartbeat output */
     showOk: z.ZodDefault<z.ZodBoolean>;
-    /** Show alerts in heartbeat output */
     showAlerts: z.ZodDefault<z.ZodBoolean>;
-    /** Consecutive failures before alerting */
     alertThreshold: z.ZodDefault<z.ZodNumber>;
-    /** Minimum ms between alerts for the same source */
     alertCooldownMs: z.ZodDefault<z.ZodNumber>;
-    /** Max ms a heartbeat tick can run before stuck detection */
     staleMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
 export declare const SchedulerConfigSchema: z.ZodObject<{
-    /** Cron job scheduling configuration */
     cron: z.ZodDefault<z.ZodObject<{
-        /** Enable cron job scheduling */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Directory for cron job state persistence */
         storeDir: z.ZodDefault<z.ZodString>;
-        /** Maximum concurrent cron job runs */
         maxConcurrentRuns: z.ZodDefault<z.ZodNumber>;
-        /** Default timezone for cron expressions (empty = UTC) */
         defaultTimezone: z.ZodDefault<z.ZodString>;
-        /** Maximum number of cron jobs allowed (0 = unlimited) */
         maxJobs: z.ZodDefault<z.ZodNumber>;
-        /** Maximum consecutive errors before auto-suspending a cron job (0 = never suspend) */
         maxConsecutiveErrors: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
-    /** Heartbeat monitoring configuration */
     heartbeat: z.ZodDefault<z.ZodObject<{
-        /** Enable periodic heartbeat checks */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Heartbeat interval in milliseconds */
         intervalMs: z.ZodDefault<z.ZodNumber>;
-        /** Show OK status in heartbeat output */
         showOk: z.ZodDefault<z.ZodBoolean>;
-        /** Show alerts in heartbeat output */
         showAlerts: z.ZodDefault<z.ZodBoolean>;
-        /** Consecutive failures before alerting */
         alertThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Minimum ms between alerts for the same source */
         alertCooldownMs: z.ZodDefault<z.ZodNumber>;
-        /** Max ms a heartbeat tick can run before stuck detection */
         staleMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
-    /** Quiet hours configuration */
     quietHours: z.ZodDefault<z.ZodObject<{
-        /** Enable quiet hours (suppress non-critical automation) */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Quiet hours start time (HH:MM format) */
         start: z.ZodDefault<z.ZodString>;
-        /** Quiet hours end time (HH:MM format) */
         end: z.ZodDefault<z.ZodString>;
-        /** Timezone for quiet hours (empty = system local) */
         timezone: z.ZodDefault<z.ZodString>;
-        /** Allow critical-priority items to bypass quiet hours */
         criticalBypass: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Execution safety configuration */
     execution: z.ZodDefault<z.ZodObject<{
-        /** Directory for execution lock files */
         lockDir: z.ZodDefault<z.ZodString>;
-        /** Lock stale timeout in milliseconds */
         staleMs: z.ZodDefault<z.ZodNumber>;
-        /** Lock update interval in milliseconds */
         updateMs: z.ZodDefault<z.ZodNumber>;
-        /** Directory for execution log files */
         logDir: z.ZodDefault<z.ZodString>;
-        /** Maximum log file size in bytes */
         maxLogBytes: z.ZodDefault<z.ZodNumber>;
-        /** Maximum lines to keep in ring-buffer log */
         keepLines: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
-    /** Task extraction from conversations */
     tasks: z.ZodDefault<z.ZodObject<{
-        /** Enable task extraction from conversations */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Minimum confidence threshold for extracted tasks (0-1) */
         confidenceThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Directory for task state persistence */
         storeDir: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/node_modules/@comis/core/dist/config/schema-secrets.d.ts

@@ -1,15 +1,12 @@
 import { z } from "zod";
 /** Per-agent secret access configuration. */
 export declare const AgentSecretsConfigSchema: z.ZodObject<{
-    /** Glob patterns for allowed secret names. Empty array = unrestricted access (backward compat). */
     allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type AgentSecretsConfig = z.infer<typeof AgentSecretsConfigSchema>;
 /** Global encrypted secrets store configuration. */
 export declare const SecretsConfigSchema: z.ZodObject<{
-    /** Enable encrypted secrets store. Default false for backward compat. */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Path to secrets.db relative to dataDir. */
     dbPath: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
 export type SecretsConfig = z.infer<typeof SecretsConfigSchema>;

package/node_modules/@comis/core/dist/config/schema-security.d.ts

@@ -6,19 +6,13 @@ import { z } from "zod";
  * and action confirmation requirements.
  */
 export declare const PermissionConfigSchema: z.ZodObject<{
-    /** Enable Node.js --permission flag enforcement */
     enableNodePermissions: z.ZodDefault<z.ZodBoolean>;
-    /** Allowed filesystem read/write paths */
     allowedFsPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    /** Allowed network hosts for outbound connections */
     allowedNetHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const ActionConfirmationConfigSchema: z.ZodObject<{
-    /** Require human confirmation for destructive actions */
     requireForDestructive: z.ZodDefault<z.ZodBoolean>;
-    /** Require human confirmation for sensitive (non-destructive but important) actions */
     requireForSensitive: z.ZodDefault<z.ZodBoolean>;
-    /** Actions that are always auto-approved (bypass confirmation) */
     autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const AgentToAgentConfigSchema: z.ZodObject<{
@@ -29,11 +23,11 @@ export declare const AgentToAgentConfigSchema: z.ZodObject<{
     waitTimeoutMs: z.ZodDefault<z.ZodNumber>;
     subAgentMaxSteps: z.ZodDefault<z.ZodNumber>;
     subAgentToolGroups: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        full: "full";
         minimal: "minimal";
         coding: "coding";
         messaging: "messaging";
         supervisor: "supervisor";
-        full: "full";
     }>>>;
     subAgentMcpTools: z.ZodDefault<z.ZodEnum<{
         none: "none";
@@ -74,29 +68,18 @@ export declare const AgentToAgentConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AgentToAgentConfig = z.infer<typeof AgentToAgentConfigSchema>;
 export declare const SecurityConfigSchema: z.ZodObject<{
-    /** Enable structured log redaction of sensitive fields */
     logRedaction: z.ZodDefault<z.ZodBoolean>;
-    /** Enable audit event logging */
     auditLog: z.ZodDefault<z.ZodBoolean>;
-    /** Node.js permission model settings */
     permission: z.ZodDefault<z.ZodObject<{
-        /** Enable Node.js --permission flag enforcement */
         enableNodePermissions: z.ZodDefault<z.ZodBoolean>;
-        /** Allowed filesystem read/write paths */
         allowedFsPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        /** Allowed network hosts for outbound connections */
         allowedNetHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    /** Action confirmation requirements */
     actionConfirmation: z.ZodDefault<z.ZodObject<{
-        /** Require human confirmation for destructive actions */
         requireForDestructive: z.ZodDefault<z.ZodBoolean>;
-        /** Require human confirmation for sensitive (non-destructive but important) actions */
         requireForSensitive: z.ZodDefault<z.ZodBoolean>;
-        /** Actions that are always auto-approved (bypass confirmation) */
         autoApprove: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    /** Agent-to-agent session messaging policy */
     agentToAgent: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxPingPongTurns: z.ZodDefault<z.ZodNumber>;
@@ -105,11 +88,11 @@ export declare const SecurityConfigSchema: z.ZodObject<{
         waitTimeoutMs: z.ZodDefault<z.ZodNumber>;
         subAgentMaxSteps: z.ZodDefault<z.ZodNumber>;
         subAgentToolGroups: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            full: "full";
             minimal: "minimal";
             coding: "coding";
             messaging: "messaging";
             supervisor: "supervisor";
-            full: "full";
         }>>>;
         subAgentMcpTools: z.ZodDefault<z.ZodEnum<{
             none: "none";
@@ -148,7 +131,6 @@ export declare const SecurityConfigSchema: z.ZodObject<{
             stuckKillThresholdMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    /** Encrypted secrets store configuration */
     secrets: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         dbPath: z.ZodDefault<z.ZodString>;

package/node_modules/@comis/core/dist/config/schema-send-policy.d.ts

@@ -14,18 +14,13 @@ export declare const SendActionSchema: z.ZodDefault<z.ZodEnum<{
  * present for the rule to be meaningful.
  */
 export declare const SendPolicyRuleSchema: z.ZodObject<{
-    /** Channel ID to match (exact string match, or omit for any) */
     channelId: z.ZodOptional<z.ZodString>;
-    /** Chat type to match: dm, group, thread, channel, forum (or omit for any) */
     chatType: z.ZodOptional<z.ZodString>;
-    /** Channel type to match: telegram, discord, slack, whatsapp (or omit for any) */
     channelType: z.ZodOptional<z.ZodString>;
-    /** Action when this rule matches */
     action: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
         deny: "deny";
     }>>;
-    /** Human-readable description for config readability */
     description: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /**
@@ -36,27 +31,19 @@ export declare const SendPolicyRuleSchema: z.ZodObject<{
  * order; first match wins. If no rule matches, the defaultAction applies.
  */
 export declare const SendPolicyConfigSchema: z.ZodObject<{
-    /** Enable send policy enforcement (default: true) */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Default action when no rules match */
     defaultAction: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
         deny: "deny";
     }>>;
-    /** Ordered list of rules (first match wins) */
     rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        /** Channel ID to match (exact string match, or omit for any) */
         channelId: z.ZodOptional<z.ZodString>;
-        /** Chat type to match: dm, group, thread, channel, forum (or omit for any) */
         chatType: z.ZodOptional<z.ZodString>;
-        /** Channel type to match: telegram, discord, slack, whatsapp (or omit for any) */
         channelType: z.ZodOptional<z.ZodString>;
-        /** Action when this rule matches */
         action: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
             deny: "deny";
         }>>;
-        /** Human-readable description for config readability */
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;

package/node_modules/@comis/core/dist/config/schema-sender-trust-display.d.ts

@@ -8,19 +8,14 @@ import { z } from "zod";
  * to human-readable aliases (operator-managed mapping).
  */
 export declare const SenderTrustDisplayConfigSchema: z.ZodObject<{
-    /** Whether sender identity is included in the message envelope */
     enabled: z.ZodDefault<z.ZodBoolean>;
-    /** Display mode: raw (platform ID), hash (HMAC prefix), or alias (operator-defined name) */
     displayMode: z.ZodDefault<z.ZodEnum<{
         raw: "raw";
         alias: "alias";
         hash: "hash";
     }>>;
-    /** Number of hex characters to show from the HMAC digest (4-16) */
     hashPrefix: z.ZodDefault<z.ZodNumber>;
-    /** SecretManager key for the HMAC secret; empty string uses agentId as fallback */
     hashSecretRef: z.ZodDefault<z.ZodString>;
-    /** Sender ID to human-readable alias mapping (used when displayMode is "alias") */
     aliases: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>;
 export type SenderTrustDisplayConfig = z.infer<typeof SenderTrustDisplayConfigSchema>;

package/node_modules/@comis/core/dist/config/schema-serializer.js

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// @allow-throw: Unknown config section guard in serializeSection(); consumed via daemon config-handlers (@allow-throw boundary).
 /**
  * Config schema serializer: converts Zod schemas to JSON Schema for agent introspection.
  *
@@ -10,43 +11,21 @@
  */
 import { z } from "zod";
 import { AppConfigSchema } from "./schema.js";
-import { PerAgentConfigSchema, RoutingConfigSchema } from "./schema-agent.js";
-import { ApprovalsConfigSchema } from "./schema-approvals.js";
-import { BrowserConfigSchema } from "./schema-browser.js";
-import { ChannelConfigSchema } from "./schema-channel.js";
-import { DaemonConfigSchema } from "./schema-daemon.js";
-import { GatewayConfigSchema } from "./schema-gateway.js";
-import { IntegrationsConfigSchema } from "./schema-integrations.js";
-import { MemoryConfigSchema } from "./schema-memory.js";
-import { MessagesConfigSchema } from "./schema-messages.js";
-import { ModelsConfigSchema } from "./schema-models.js";
-import { MonitoringConfigSchema } from "./schema-observability.js";
-import { ProvidersConfigSchema } from "./schema-providers.js";
-import { SchedulerConfigSchema } from "./schema-scheduler.js";
-import { SecurityConfigSchema } from "./schema-security.js";
+import { SECTION_REGISTRY } from "./section-registry.js";
 // ---------------------------------------------------------------------------
 // Section schema lookup
 // ---------------------------------------------------------------------------
 /**
  * Maps config section names to their Zod schema objects.
+ *
+ * Derived from SECTION_REGISTRY. The legacy standalone SECTION_SCHEMAS
+ * literal previously held its own 16-entry list and drifted from
+ * field-metadata.ts and managed-sections.ts. Now there is a single source
+ * of truth.
  */
-const SECTION_SCHEMAS = {
-    agents: PerAgentConfigSchema,
-    channels: ChannelConfigSchema,
-    memory: MemoryConfigSchema,
-    security: SecurityConfigSchema,
-    routing: RoutingConfigSchema,
-    daemon: DaemonConfigSchema,
-    scheduler: SchedulerConfigSchema,
-    gateway: GatewayConfigSchema,
-    integrations: IntegrationsConfigSchema,
-    monitoring: MonitoringConfigSchema,
-    browser: BrowserConfigSchema,
-    models: ModelsConfigSchema,
-    providers: ProvidersConfigSchema,
-    messages: MessagesConfigSchema,
-    approvals: ApprovalsConfigSchema,
-};
+const SECTION_SCHEMAS = Object.fromEntries(Object.entries(SECTION_REGISTRY)
+    .filter(([, entry]) => entry.schemaSerializable)
+    .map(([name, entry]) => [name, entry.schema]));
 // ---------------------------------------------------------------------------
 // Full schema cache
 // ---------------------------------------------------------------------------