comisai 1.0.36 → 1.0.37

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<{
@@ -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>;
@@ -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

@@ -24,6 +24,7 @@ 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 { ToolingConfigSchema } from "./schema-tooling.js";
 // ---------------------------------------------------------------------------
 // Section schema lookup
 // ---------------------------------------------------------------------------
@@ -46,6 +47,7 @@ const SECTION_SCHEMAS = {
     providers: ProvidersConfigSchema,
     messages: MessagesConfigSchema,
     approvals: ApprovalsConfigSchema,
+    tooling: ToolingConfigSchema,
 };
 // ---------------------------------------------------------------------------
 // Full schema cache

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

@@ -4,15 +4,10 @@ import { z } from "zod";
  * Controls limits, behavior, and eligibility for Markdown instruction skills.
  */
 export declare const PromptSkillsConfigSchema: z.ZodObject<{
-    /** Maximum skill body length in characters (default: 20000) */
     maxBodyLength: z.ZodDefault<z.ZodNumber>;
-    /** Enable dynamic context -- shell command execution in skill bodies (default: false) */
     enableDynamicContext: z.ZodDefault<z.ZodBoolean>;
-    /** Maximum prompt skills auto-injected per request (default: 3) */
     maxAutoInject: z.ZodDefault<z.ZodNumber>;
-    /** Skill names allowed for this agent. Empty array = allow all discovered skills. */
     allowedSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    /** Skill names denied for this agent. Applied after allowedSkills filter. */
     deniedSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 /**
@@ -23,50 +18,26 @@ export declare const PromptSkillsConfigSchema: z.ZodObject<{
  * per-deployment without a rebuild.
  */
 declare const ToolDiscoverySchema: z.ZodObject<{
-    /** Minimum BM25 score as FRACTION OF TOP MATCH (0..1). Default 0.8.
-     *  BM25 scores are normalized to [0, 1] before this floor applies,
-     *  matching the semantics of minHybridScore. A value of 0.8 means
-     *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
-     *  validation at config load (stale raw-score overrides would produce zero
-     *  matches under the new normalized semantics; fail-fast surfaces the
-     *  error immediately per AGENTS.md §3.4). */
     minBm25Score: z.ZodDefault<z.ZodNumber>;
-    /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
     minHybridScore: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const SkillsConfigSchema: z.ZodObject<{
-    /** Directories to scan for SKILL.md files (relative to data dir) */
     discoveryPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    /** Built-in tool toggles (enabled/disabled by config) */
     builtinTools: z.ZodDefault<z.ZodObject<{
-        /** Read file contents with line numbers and pagination */
         read: z.ZodDefault<z.ZodBoolean>;
-        /** Write or overwrite files; auto-creates parent directories */
         write: z.ZodDefault<z.ZodBoolean>;
-        /** Surgical search-and-replace on files (exact text match) */
         edit: z.ZodDefault<z.ZodBoolean>;
-        /** Cell-level Jupyter notebook editing */
         notebookEdit: z.ZodDefault<z.ZodBoolean>;
-        /** Regex search across files (ripgrep-based, respects .gitignore). Requires `rg` system binary. */
         grep: z.ZodDefault<z.ZodBoolean>;
-        /** Find files by glob pattern (fd-based, respects .gitignore). Requires `fd` system binary. */
         find: z.ZodDefault<z.ZodBoolean>;
-        /** List directory contents alphabetically, including dotfiles */
         ls: z.ZodDefault<z.ZodBoolean>;
-        /** Shell command execution with foreground/background modes */
         exec: z.ZodDefault<z.ZodBoolean>;
-        /** Background process management (list, kill, status, log) */
         process: z.ZodDefault<z.ZodBoolean>;
-        /** Web search API integration */
         webSearch: z.ZodDefault<z.ZodBoolean>;
-        /** URL content fetching */
         webFetch: z.ZodDefault<z.ZodBoolean>;
-        /** Headless browser control (requires Playwright/Chromium) */
         browser: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Tool policy: controls which tools are available per agent */
     toolPolicy: z.ZodDefault<z.ZodObject<{
-        /** Named profile: controls baseline tool set */
         profile: z.ZodDefault<z.ZodEnum<{
             minimal: "minimal";
             coding: "coding";
@@ -74,67 +45,35 @@ export declare const SkillsConfigSchema: z.ZodObject<{
             supervisor: "supervisor";
             full: "full";
         }>>;
-        /** Additional tools to allow beyond the profile (tool names or group:xxx) */
         allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        /** Tools to deny even if in the profile (tool names or group:xxx) */
         deny: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    /** Prompt-based skill configuration (Markdown instruction skills) */
     promptSkills: z.ZodDefault<z.ZodObject<{
-        /** Maximum skill body length in characters (default: 20000) */
         maxBodyLength: z.ZodDefault<z.ZodNumber>;
-        /** Enable dynamic context -- shell command execution in skill bodies (default: false) */
         enableDynamicContext: z.ZodDefault<z.ZodBoolean>;
-        /** Maximum prompt skills auto-injected per request (default: 3) */
         maxAutoInject: z.ZodDefault<z.ZodNumber>;
-        /** Skill names allowed for this agent. Empty array = allow all discovered skills. */
         allowedSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        /** Skill names denied for this agent. Applied after allowedSkills filter. */
         deniedSkills: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    /** Runtime eligibility filtering: exclude skills whose OS/binary/env prerequisites are not met */
     runtimeEligibility: z.ZodDefault<z.ZodObject<{
-        /** Enable runtime eligibility filtering based on os, binary, and env var prerequisites (default: true). */
         enabled: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Content scanning: detect dangerous patterns in skill bodies at load time */
     contentScanning: z.ZodDefault<z.ZodObject<{
-        /** Enable content scanning at skill load time (default: true). */
         enabled: z.ZodDefault<z.ZodBoolean>;
-        /** Block skill loading when CRITICAL findings are present (default: true). */
         blockOnCritical: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
-    /** Exec tool OS-level sandbox configuration */
     execSandbox: z.ZodDefault<z.ZodObject<{
-        /**
-         * Whether OS-level sandboxing is active for exec tool commands.
-         * - "always": sandbox is enabled; if the sandbox binary is unavailable the
-         *   exec tool logs a warning and runs unsandboxed (graceful fallback).
-         * - "never": sandbox is unconditionally disabled.
-         */
         enabled: z.ZodDefault<z.ZodEnum<{
             never: "never";
             always: "always";
         }>>;
-        /** Additional read-only paths to expose inside the sandbox (e.g., shared data dirs). */
         readOnlyAllowPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    /** discover_tools score-floor thresholds (BM25 + hybrid). */
     toolDiscovery: z.ZodDefault<z.ZodObject<{
-        /** Minimum BM25 score as FRACTION OF TOP MATCH (0..1). Default 0.8.
-         *  BM25 scores are normalized to [0, 1] before this floor applies,
-         *  matching the semantics of minHybridScore. A value of 0.8 means
-         *  "return only tools scoring >= 80% of the top match". Values > 1.0 fail
-         *  validation at config load (stale raw-score overrides would produce zero
-         *  matches under the new normalized semantics; fail-fast surfaces the
-         *  error immediately per AGENTS.md §3.4). */
         minBm25Score: z.ZodDefault<z.ZodNumber>;
-        /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
         minHybridScore: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
-    /** Enable file watching for automatic skill reload (default: true). */
     watchEnabled: z.ZodDefault<z.ZodBoolean>;
-    /** Debounce interval in milliseconds for file change coalescing (default: 400). */
     watchDebounceMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 /** Inferred skills configuration type. */