comisai 1.0.4

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

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+import { z } from "zod";
+/**
+ * Send action: allow or deny an outbound message.
+ */
+export const SendActionSchema = z.enum(["allow", "deny"]).default("allow");
+/**
+ * A single send policy rule.
+ *
+ * Rules are evaluated in order (first match wins). Each field is optional;
+ * omitted fields match any value. At least one matching field should be
+ * present for the rule to be meaningful.
+ */
+export const SendPolicyRuleSchema = z.strictObject({
+    /** Channel ID to match (exact string match, or omit for any) */
+    channelId: z.string().min(1).optional(),
+    /** Chat type to match: dm, group, thread, channel, forum (or omit for any) */
+    chatType: z.string().min(1).optional(),
+    /** Channel type to match: telegram, discord, slack, whatsapp (or omit for any) */
+    channelType: z.string().min(1).optional(),
+    /** Action when this rule matches */
+    action: SendActionSchema,
+    /** Human-readable description for config readability */
+    description: z.string().optional(),
+});
+/**
+ * Send policy configuration.
+ *
+ * Controls whether the agent is allowed to send outbound messages to a
+ * given channel/chatType/channelType combination. Rules are evaluated in
+ * order; first match wins. If no rule matches, the defaultAction applies.
+ */
+export const SendPolicyConfigSchema = z.strictObject({
+    /** Enable send policy enforcement (default: true) */
+    enabled: z.boolean().default(true),
+    /** Default action when no rules match */
+    defaultAction: SendActionSchema,
+    /** Ordered list of rules (first match wins) */
+    rules: z.array(SendPolicyRuleSchema).default([]),
+});

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/**
+ * Sender trust display configuration schema.
+ *
+ * Controls how sender identity is surfaced to the LLM in the message
+ * envelope. Modes range from raw platform IDs (transparent but privacy-weak)
+ * to HMAC-hashed prefixes (privacy-preserving but still uniquely identifying)
+ * 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-sender-trust-display.js

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+import { z } from "zod";
+/**
+ * Sender trust display configuration schema.
+ *
+ * Controls how sender identity is surfaced to the LLM in the message
+ * envelope. Modes range from raw platform IDs (transparent but privacy-weak)
+ * to HMAC-hashed prefixes (privacy-preserving but still uniquely identifying)
+ * to human-readable aliases (operator-managed mapping).
+ */
+export const SenderTrustDisplayConfigSchema = z.strictObject({
+    /** Whether sender identity is included in the message envelope */
+    enabled: z.boolean().default(false),
+    /** Display mode: raw (platform ID), hash (HMAC prefix), or alias (operator-defined name) */
+    displayMode: z.enum(["raw", "hash", "alias"]).default("hash"),
+    /** Number of hex characters to show from the HMAC digest (4-16) */
+    hashPrefix: z.number().int().min(4).max(16).default(8),
+    /** SecretManager key for the HMAC secret; empty string uses agentId as fallback */
+    hashSecretRef: z.string().default(""),
+    /** Sender ID to human-readable alias mapping (used when displayMode is "alias") */
+    aliases: z.record(z.string(), z.string()).default({}),
+});

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

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

package/node_modules/@comis/core/dist/config/schema-sender-trust-display.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import { SenderTrustDisplayConfigSchema } from "./schema-sender-trust-display.js";
+describe("SenderTrustDisplayConfigSchema", () => {
+    it("produces valid defaults from empty object", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({});
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.enabled).toBe(false);
+            expect(result.data.displayMode).toBe("hash");
+            expect(result.data.hashPrefix).toBe(8);
+            expect(result.data.hashSecretRef).toBe("");
+            expect(result.data.aliases).toEqual({});
+        }
+    });
+    it("accepts fully specified config", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({
+            enabled: true,
+            displayMode: "alias",
+            hashPrefix: 12,
+            hashSecretRef: "secrets/hmac-key",
+            aliases: {
+                "user-123": "Alice",
+                "user-456": "Bob",
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.enabled).toBe(true);
+            expect(result.data.displayMode).toBe("alias");
+            expect(result.data.hashPrefix).toBe(12);
+            expect(result.data.hashSecretRef).toBe("secrets/hmac-key");
+            expect(result.data.aliases["user-123"]).toBe("Alice");
+        }
+    });
+    it("rejects unknown keys (strictObject)", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({
+            enabled: true,
+            unknownField: "should-fail",
+        });
+        expect(result.success).toBe(false);
+    });
+    it("rejects invalid displayMode enum value", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({
+            displayMode: "obfuscated",
+        });
+        expect(result.success).toBe(false);
+    });
+    it("rejects hashPrefix below minimum (4)", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({
+            hashPrefix: 3,
+        });
+        expect(result.success).toBe(false);
+    });
+    it("rejects hashPrefix above maximum (16)", () => {
+        const result = SenderTrustDisplayConfigSchema.safeParse({
+            hashPrefix: 17,
+        });
+        expect(result.success).toBe(false);
+    });
+});

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

@@ -0,0 +1,33 @@
+/**
+ * Config schema serializer: converts Zod schemas to JSON Schema for agent introspection.
+ *
+ * Provides cached conversion of the full AppConfig schema and per-section schemas
+ * to JSON Schema format. This allows agents to introspect the configuration structure
+ * and understand valid values before attempting config patches.
+ *
+ * @module
+ */
+/**
+ * Convert the AppConfig schema (or a specific section) to JSON Schema.
+ *
+ * When called without arguments, returns the full AppConfig JSON Schema
+ * (cached after first call). When called with a section name, returns the
+ * JSON Schema for that section only (not cached -- section schemas are small).
+ *
+ * @param section - Optional section name (e.g., "agent", "gateway")
+ * @returns JSON Schema object
+ * @throws Error if section name is not recognized
+ *
+ * @example
+ * const full = getConfigSchema(); // full AppConfig schema
+ * const agent = getConfigSchema("agent"); // agent section only
+ */
+export declare function getConfigSchema(section?: string): Record<string, unknown>;
+/**
+ * Get the list of available config section names.
+ *
+ * Useful for agents to discover which sections can be queried individually.
+ *
+ * @returns Array of section name strings
+ */
+export declare function getConfigSections(): string[];

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

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Config schema serializer: converts Zod schemas to JSON Schema for agent introspection.
+ *
+ * Provides cached conversion of the full AppConfig schema and per-section schemas
+ * to JSON Schema format. This allows agents to introspect the configuration structure
+ * and understand valid values before attempting config patches.
+ *
+ * @module
+ */
+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";
+// ---------------------------------------------------------------------------
+// Section schema lookup
+// ---------------------------------------------------------------------------
+/**
+ * Maps config section names to their Zod schema objects.
+ */
+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,
+};
+// ---------------------------------------------------------------------------
+// Full schema cache
+// ---------------------------------------------------------------------------
+let fullSchemaCache;
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Convert the AppConfig schema (or a specific section) to JSON Schema.
+ *
+ * When called without arguments, returns the full AppConfig JSON Schema
+ * (cached after first call). When called with a section name, returns the
+ * JSON Schema for that section only (not cached -- section schemas are small).
+ *
+ * @param section - Optional section name (e.g., "agent", "gateway")
+ * @returns JSON Schema object
+ * @throws Error if section name is not recognized
+ *
+ * @example
+ * const full = getConfigSchema(); // full AppConfig schema
+ * const agent = getConfigSchema("agent"); // agent section only
+ */
+export function getConfigSchema(section) {
+    if (section !== undefined) {
+        const sectionSchema = SECTION_SCHEMAS[section];
+        if (!sectionSchema) {
+            throw new Error(`Unknown config section: ${section}`);
+        }
+        return z.toJSONSchema(sectionSchema, { reused: "inline", unrepresentable: "any" });
+    }
+    if (!fullSchemaCache) {
+        fullSchemaCache = z.toJSONSchema(AppConfigSchema, {
+            reused: "inline",
+            unrepresentable: "any",
+        });
+    }
+    return fullSchemaCache;
+}
+/**
+ * Get the list of available config section names.
+ *
+ * Useful for agents to discover which sections can be queried individually.
+ *
+ * @returns Array of section name strings
+ */
+export function getConfigSections() {
+    return Object.keys(SECTION_SCHEMAS);
+}

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

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

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

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { getConfigSchema, getConfigSections } from "./schema-serializer.js";
+describe("getConfigSchema", () => {
+    it("returns full schema with type property", () => {
+        const schema = getConfigSchema();
+        expect(schema).toBeDefined();
+        expect(typeof schema).toBe("object");
+        // JSON Schema always has a type or definitions at the top level
+        expect(schema).toHaveProperty("type");
+    });
+    it("caches the full schema (same reference on second call)", () => {
+        const first = getConfigSchema();
+        const second = getConfigSchema();
+        expect(first).toBe(second);
+    });
+    it("returns section-specific schema for agents", () => {
+        const schema = getConfigSchema("agents");
+        expect(schema).toBeDefined();
+        expect(typeof schema).toBe("object");
+        expect(schema).toHaveProperty("type");
+    });
+    it("returns section-specific schema for gateway", () => {
+        const schema = getConfigSchema("gateway");
+        expect(schema).toBeDefined();
+        expect(typeof schema).toBe("object");
+        expect(schema).toHaveProperty("type");
+    });
+    it("throws for unknown section name", () => {
+        expect(() => getConfigSchema("unknown_section")).toThrow("Unknown config section: unknown_section");
+    });
+    it("throws for empty string section", () => {
+        expect(() => getConfigSchema("")).toThrow("Unknown config section: ");
+    });
+    it("getConfigSchema('agents') returns JSON Schema for per-agent config", () => {
+        const schema = getConfigSchema("agents");
+        expect(schema).toHaveProperty("type");
+        // PerAgentConfigSchema is an object type with agent properties
+        expect(schema.type).toBe("object");
+        const sections = getConfigSections();
+        expect(sections).toContain("agents");
+    });
+});
+describe("getConfigSections", () => {
+    it("returns an array of section names", () => {
+        const sections = getConfigSections();
+        expect(Array.isArray(sections)).toBe(true);
+        expect(sections.length).toBeGreaterThan(0);
+    });
+    it("contains agents, security, and gateway", () => {
+        const sections = getConfigSections();
+        expect(sections).toContain("agents");
+        expect(sections).toContain("security");
+        expect(sections).toContain("gateway");
+    });
+    it("contains all 15 sections", () => {
+        const sections = getConfigSections();
+        expect(sections).toHaveLength(15);
+        expect(sections).toContain("agents");
+        expect(sections).toContain("channels");
+        expect(sections).toContain("memory");
+        expect(sections).toContain("routing");
+        expect(sections).toContain("daemon");
+        expect(sections).toContain("scheduler");
+        expect(sections).toContain("integrations");
+        expect(sections).toContain("monitoring");
+        // CFG-07: New config sections
+        expect(sections).toContain("browser");
+        expect(sections).toContain("models");
+        expect(sections).toContain("providers");
+        expect(sections).toContain("messages");
+        expect(sections).toContain("approvals");
+    });
+});

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

@@ -0,0 +1,134 @@
+import { z } from "zod";
+/**
+ * Prompt-based skills configuration.
+ * 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>;
+/**
+ * discover_tools score-floor configuration.
+ * Why: zero-signal queries can surface incidental BM25 matches or cosine-noise
+ * hits. Thresholds filter ranked results before slicing, forcing "no matches"
+ * responses when nothing crosses the floor. Tunable so operators can adjust
+ * per-deployment without a rebuild.
+ */
+declare const ToolDiscoverySchema: z.ZodObject<{
+    /** Minimum BM25 score to consider a match (BM25-only mode). Default 0.8. */
+    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";
+            messaging: "messaging";
+            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 to consider a match (BM25-only mode). Default 0.8. */
+        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. */
+export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+/** Inferred prompt skills configuration type. */
+export type PromptSkillsConfig = z.infer<typeof PromptSkillsConfigSchema>;
+/** Inferred tool discovery configuration type. */
+export type ToolDiscoveryConfig = z.infer<typeof ToolDiscoverySchema>;
+export {};

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

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+import { z } from "zod";
+/**
+ * Skills system configuration schema.
+ *
+ * Controls skill discovery paths, built-in tool toggles,
+ * prompt skill configuration, and eligibility filtering.
+ */
+const BuiltinToolsSchema = z.strictObject({
+    /** Read file contents with line numbers and pagination */
+    read: z.boolean().default(true),
+    /** Write or overwrite files; auto-creates parent directories */
+    write: z.boolean().default(true),
+    /** Surgical search-and-replace on files (exact text match) */
+    edit: z.boolean().default(true),
+    /** Cell-level Jupyter notebook editing */
+    notebookEdit: z.boolean().default(true),
+    /** Regex search across files (ripgrep-based, respects .gitignore). Requires `rg` system binary. */
+    grep: z.boolean().default(true),
+    /** Find files by glob pattern (fd-based, respects .gitignore). Requires `fd` system binary. */
+    find: z.boolean().default(true),
+    /** List directory contents alphabetically, including dotfiles */
+    ls: z.boolean().default(true),
+    /** Shell command execution with foreground/background modes */
+    exec: z.boolean().default(true),
+    /** Background process management (list, kill, status, log) */
+    process: z.boolean().default(true),
+    /** Web search API integration */
+    webSearch: z.boolean().default(true),
+    /** URL content fetching */
+    webFetch: z.boolean().default(true),
+    /** Headless browser control (requires Playwright/Chromium) */
+    browser: z.boolean().default(false),
+});
+const ToolPolicySchema = z.strictObject({
+    /** Named profile: controls baseline tool set */
+    profile: z.enum(["minimal", "coding", "messaging", "supervisor", "full"]).default("full"),
+    /** Additional tools to allow beyond the profile (tool names or group:xxx) */
+    allow: z.array(z.string()).default([]),
+    /** Tools to deny even if in the profile (tool names or group:xxx) */
+    deny: z.array(z.string()).default([]),
+});
+/**
+ * Prompt-based skills configuration.
+ * Controls limits, behavior, and eligibility for Markdown instruction skills.
+ */
+export const PromptSkillsConfigSchema = z.strictObject({
+    /** Maximum skill body length in characters (default: 20000) */
+    maxBodyLength: z.number().int().positive().default(20_000),
+    /** Enable dynamic context -- shell command execution in skill bodies (default: false) */
+    enableDynamicContext: z.boolean().default(false),
+    /** Maximum prompt skills auto-injected per request (default: 3) */
+    maxAutoInject: z.number().int().min(0).max(20).default(3),
+    /** Skill names allowed for this agent. Empty array = allow all discovered skills. */
+    allowedSkills: z.array(z.string()).default([]),
+    /** Skill names denied for this agent. Applied after allowedSkills filter. */
+    deniedSkills: z.array(z.string()).default([]),
+});
+/** Runtime eligibility filtering configuration. */
+const RuntimeEligibilitySchema = z.strictObject({
+    /** Enable runtime eligibility filtering based on os, binary, and env var prerequisites (default: true). */
+    enabled: z.boolean().default(true),
+});
+/** Content scanning configuration for skill bodies at load time. */
+const ContentScanningSchema = z.strictObject({
+    /** Enable content scanning at skill load time (default: true). */
+    enabled: z.boolean().default(true),
+    /** Block skill loading when CRITICAL findings are present (default: true). */
+    blockOnCritical: z.boolean().default(true),
+});
+/**
+ * Exec tool OS-level sandbox configuration.
+ *
+ * Controls whether child processes spawned by the exec tool are wrapped
+ * in a platform sandbox (bwrap on Linux, sandbox-exec on macOS).
+ */
+const ExecSandboxSchema = z.strictObject({
+    /**
+     * 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.enum(["always", "never"]).default("always"),
+    /** Additional read-only paths to expose inside the sandbox (e.g., shared data dirs). */
+    readOnlyAllowPaths: z.array(z.string()).default([]),
+});
+/**
+ * discover_tools score-floor configuration.
+ * Why: zero-signal queries can surface incidental BM25 matches or cosine-noise
+ * hits. Thresholds filter ranked results before slicing, forcing "no matches"
+ * responses when nothing crosses the floor. Tunable so operators can adjust
+ * per-deployment without a rebuild.
+ */
+const ToolDiscoverySchema = z.strictObject({
+    /** Minimum BM25 score to consider a match (BM25-only mode). Default 0.8. */
+    minBm25Score: z.number().min(0).default(0.8),
+    /** Minimum combined score (0..1 normalized) for hybrid mode. Default 0.35. */
+    minHybridScore: z.number().min(0).max(1).default(0.35),
+});
+export const SkillsConfigSchema = z.strictObject({
+    /** Directories to scan for SKILL.md files (relative to data dir) */
+    discoveryPaths: z.array(z.string()).default(["./skills"]),
+    /** Built-in tool toggles (enabled/disabled by config) */
+    builtinTools: BuiltinToolsSchema.default(() => BuiltinToolsSchema.parse({})),
+    /** Tool policy: controls which tools are available per agent */
+    toolPolicy: ToolPolicySchema.default(() => ToolPolicySchema.parse({})),
+    /** Prompt-based skill configuration (Markdown instruction skills) */
+    promptSkills: PromptSkillsConfigSchema.default(() => PromptSkillsConfigSchema.parse({})),
+    /** Runtime eligibility filtering: exclude skills whose OS/binary/env prerequisites are not met */
+    runtimeEligibility: RuntimeEligibilitySchema.default(() => RuntimeEligibilitySchema.parse({})),
+    /** Content scanning: detect dangerous patterns in skill bodies at load time */
+    contentScanning: ContentScanningSchema.default(() => ContentScanningSchema.parse({})),
+    /** Exec tool OS-level sandbox configuration */
+    execSandbox: ExecSandboxSchema.default(() => ExecSandboxSchema.parse({})),
+    /** discover_tools score-floor thresholds (BM25 + hybrid). */
+    toolDiscovery: ToolDiscoverySchema.default(() => ToolDiscoverySchema.parse({})),
+    /** Enable file watching for automatic skill reload (default: true). */
+    watchEnabled: z.boolean().default(true),
+    /** Debounce interval in milliseconds for file change coalescing (default: 400). */
+    watchDebounceMs: z.number().int().min(100).max(5000).default(400),
+});