@newsails/veil-cli 1.0.1

package/llm/client.js

@@ -0,0 +1,206 @@
+'use strict';
+
+/**
+ * Native fetch-based LLM client.
+ * No SDK dependency — works with any OpenAI-compatible endpoint.
+ */
+
+/**
+ * Build the request body shared by streaming and non-streaming calls.
+ */
+function buildRequestBody({ model, messages, tools = [], temperature, reasoning, maxTokens, thinking, modalities, audio, stream }) {
+  const body = { model, messages };
+  if (tools.length > 0) body.tools = tools;
+  if (temperature !== undefined) body.temperature = temperature;
+  if (reasoning) body.reasoning = { effort: reasoning };
+  if (thinking) body.thinking = thinking;
+  if (maxTokens !== undefined) body.max_tokens = maxTokens;
+  if (modalities) body.modalities = modalities;
+  if (audio) body.audio = audio;
+  if (stream) body.stream = true;
+  return body;
+}
+
+function buildHeaders(apiKey) {
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${apiKey || ''}`,
+    'HTTP-Referer': 'https://veil.com',
+    'X-Title': 'VeilCLI',
+  };
+}
+
+/**
+ * Call the LLM API.
+ * If `onChunk` is provided, uses server-sent events streaming internally and calls
+ * `onChunk(text)` for each content delta. The return value is always the same shape
+ * as a non-streaming response.
+ *
+ * @param {{ baseUrl: string, apiKey: string, model: string, messages: Object[], tools?: Object[], temperature?: number, reasoning?: string, maxTokens?: number, thinking?: Object, onChunk?: (text: string) => void }} opts
+ * @returns {Promise<Object>} Raw API response body (OpenAI-compatible shape)
+ */
+async function callLLM({ baseUrl, apiKey, model, messages, tools = [], temperature, reasoning, maxTokens, thinking, modalities, audio, onChunk, onToolStart }) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new Error('callLLM: messages must be a non-empty array');
+  }
+  if (!Array.isArray(tools)) {
+    throw new Error('callLLM: tools must be an array');
+  }
+  if (!model) throw new Error('callLLM: model is required');
+  if (!baseUrl) throw new Error('callLLM: baseUrl is required');
+
+  // Audio output requires streaming internally (provider requirement)
+  const needsStreaming = !!onChunk || (Array.isArray(modalities) && modalities.includes('audio'));
+  if (needsStreaming) {
+    return callLLMStreaming({ baseUrl, apiKey, model, messages, tools, temperature, reasoning, maxTokens, thinking, modalities, audio, onChunk: onChunk || (() => {}), onToolStart });
+  }
+
+  const body = buildRequestBody({ model, messages, tools, temperature, reasoning, maxTokens, thinking, modalities, audio });
+
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: buildHeaders(apiKey),
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    let errText = '';
+    try { errText = await response.text(); } catch {}
+    throw new Error(`LLM API error ${response.status}: ${errText.slice(0, 500)}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Internal: streaming callLLM. Parses SSE deltas, calls onChunk for content tokens,
+ * reassembles tool call deltas, and returns a response in the same shape as callLLM.
+ */
+async function callLLMStreaming({ baseUrl, apiKey, model, messages, tools = [], temperature, reasoning, maxTokens, thinking, modalities, audio, onChunk, onToolStart }) {
+  const body = buildRequestBody({ model, messages, tools, temperature, reasoning, maxTokens, thinking, modalities, audio, stream: true });
+
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: buildHeaders(apiKey),
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    let errText = '';
+    try { errText = await response.text(); } catch {}
+    throw new Error(`LLM API error ${response.status}: ${errText.slice(0, 500)}`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  let fullContent = '';
+  let finishReason = 'stop';
+  const toolCallBuffers = {};
+  const toolNameEmitted = new Set();
+  const audioChunks = [];
+  let usageData = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop();
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('data: ')) continue;
+      const payload = trimmed.slice(6);
+      if (payload === '[DONE]') continue;
+
+      let chunk;
+      try { chunk = JSON.parse(payload); } catch { continue; }
+
+      if (chunk.usage) usageData = chunk.usage;
+
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finishReason = choice.finish_reason;
+
+      const delta = choice.delta || {};
+
+      if (delta.content) {
+        fullContent += delta.content;
+        onChunk(delta.content);
+      }
+
+      if (delta.audio?.data) {
+        audioChunks.push(delta.audio.data);
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!toolCallBuffers[idx]) {
+            toolCallBuffers[idx] = { id: '', type: 'function', function: { name: '', arguments: '' } };
+          }
+          if (tc.id) toolCallBuffers[idx].id = tc.id;
+          if (tc.function?.name) {
+            toolCallBuffers[idx].function.name += tc.function.name;
+            if (!toolNameEmitted.has(idx) && toolCallBuffers[idx].function.name) {
+              toolNameEmitted.add(idx);
+              onToolStart?.(toolCallBuffers[idx].function.name);
+            }
+          }
+          if (tc.function?.arguments) toolCallBuffers[idx].function.arguments += tc.function.arguments;
+        }
+      }
+    }
+  }
+
+  const toolCallsArray = Object.keys(toolCallBuffers).length > 0 ? Object.values(toolCallBuffers) : null;
+
+  return {
+    choices: [{
+      message: {
+        content: fullContent || null,
+        audio: audioChunks.length > 0 ? { data: audioChunks.join('') } : null,
+        tool_calls: toolCallsArray,
+      },
+      finish_reason: finishReason,
+    }],
+    usage: usageData || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}
+
+/**
+ * Extract the assistant message from an API response.
+ * @param {Object} response - Raw API response
+ * @returns {{ content: string|null, toolCalls: Object[]|null, finishReason: string }}
+ */
+function extractMessage(response) {
+  const choice = response.choices && response.choices[0];
+  if (!choice) throw new Error('LLM response had no choices');
+
+  const msg = choice.message;
+  return {
+    content: msg.content || null,
+    audio: msg.audio || null,
+    toolCalls: msg.tool_calls && msg.tool_calls.length > 0 ? msg.tool_calls : null,
+    finishReason: choice.finish_reason || 'stop',
+  };
+}
+
+/**
+ * Extract token usage from an API response.
+ * @param {Object} response - Raw API response
+ * @returns {{ input: number, output: number, cache: number, cost: number }}
+ */
+function extractUsage(response) {
+  const usage = response.usage || {};
+  return {
+    input: usage.prompt_tokens || 0,
+    output: usage.completion_tokens || 0,
+    cache: usage.prompt_tokens_details?.cached_tokens || 0,
+    cost: usage.cost || 0,
+  };
+}
+
+module.exports = { callLLM, extractMessage, extractUsage };

package/migrations/001-initial.sql

@@ -0,0 +1,121 @@
+-- VeilCLI Initial Schema
+-- All statements use IF NOT EXISTS (idempotent — safe to run on every startup)
+
+CREATE TABLE IF NOT EXISTS schema_version (
+  version    INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id               TEXT PRIMARY KEY,
+  agent_name       TEXT NOT NULL,
+  mode             TEXT NOT NULL CHECK(mode IN ('chat','task','daemon','subagent')),
+  instance_folder  TEXT,
+  status           TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','closed')),
+  model            TEXT,
+  title            TEXT,
+  message_count    INTEGER NOT NULL DEFAULT 0,
+  token_input      INTEGER NOT NULL DEFAULT 0,
+  token_output     INTEGER NOT NULL DEFAULT 0,
+  token_cache      INTEGER NOT NULL DEFAULT 0,
+  estimated_cost   REAL NOT NULL DEFAULT 0,
+  compaction_count INTEGER NOT NULL DEFAULT 0,
+  created_at       TEXT NOT NULL,
+  updated_at       TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id   TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  role         TEXT NOT NULL CHECK(role IN ('system','user','assistant','tool')),
+  content      TEXT,
+  tool_calls   TEXT,
+  tool_call_id TEXT,
+  token_count  INTEGER,
+  created_at   TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id                   TEXT PRIMARY KEY,
+  session_id           TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+  agent_name           TEXT NOT NULL,
+  status               TEXT NOT NULL DEFAULT 'pending'
+                         CHECK(status IN ('pending','processing','waiting','finished','failed','canceled')),
+  priority             TEXT NOT NULL DEFAULT 'normal' CHECK(priority IN ('high','normal','low')),
+  parent_task_id       TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+  input                TEXT,
+  output               TEXT,
+  error                TEXT,
+  tags                 TEXT,
+  iterations           INTEGER NOT NULL DEFAULT 0,
+  max_iterations       INTEGER,
+  max_duration_seconds INTEGER,
+  token_input          INTEGER NOT NULL DEFAULT 0,
+  token_output         INTEGER NOT NULL DEFAULT 0,
+  token_cache          INTEGER NOT NULL DEFAULT 0,
+  estimated_cost       REAL NOT NULL DEFAULT 0,
+  instance_folder      TEXT,
+  created_at           TEXT NOT NULL,
+  started_at           TEXT,
+  finished_at          TEXT,
+  updated_at           TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS task_events (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id    TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  type       TEXT NOT NULL,
+  data       TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS todos (
+  session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
+  items      TEXT NOT NULL DEFAULT '[]',
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent_messages (
+  id                TEXT PRIMARY KEY,
+  target_agent      TEXT NOT NULL,
+  target_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+  from_agent        TEXT NOT NULL,
+  content           TEXT NOT NULL,
+  followup          INTEGER NOT NULL DEFAULT 0,
+  skill             TEXT,
+  status            TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','delivered','expired')),
+  correlation_id    TEXT,
+  response          TEXT,
+  created_at        TEXT NOT NULL,
+  delivered_at      TEXT
+);
+
+CREATE TABLE IF NOT EXISTS task_subscriptions (
+  id                    INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id               TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  subscriber_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  subscriber_agent      TEXT NOT NULL,
+  status                TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','delivered')),
+  created_at            TEXT NOT NULL,
+  delivered_at          TEXT
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_sessions_agent   ON sessions(agent_name);
+CREATE INDEX IF NOT EXISTS idx_sessions_status  ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_created ON sessions(created_at);
+CREATE INDEX IF NOT EXISTS idx_sessions_folder  ON sessions(instance_folder);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_agent    ON tasks(agent_name);
+CREATE INDEX IF NOT EXISTS idx_tasks_status   ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent   ON tasks(parent_task_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_created  ON tasks(created_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_folder   ON tasks(instance_folder);
+
+CREATE INDEX IF NOT EXISTS idx_task_events_task ON task_events(task_id);
+
+CREATE INDEX IF NOT EXISTS idx_agent_messages_target ON agent_messages(target_agent, status);
+
+CREATE INDEX IF NOT EXISTS idx_task_subscriptions_task ON task_subscriptions(task_id, status);

package/migrations/002-debuggability.sql

@@ -0,0 +1,13 @@
+-- VeilCLI Debuggability Migration
+-- Adds: token_budget and tags on tasks, task_context table for LLM context snapshots
+-- Note: These columns may already exist from migration 001 - the runtime handles this gracefully
+
+CREATE TABLE IF NOT EXISTS task_context (
+  task_id    TEXT PRIMARY KEY REFERENCES tasks(id) ON DELETE CASCADE,
+  messages   TEXT NOT NULL,
+  tools      TEXT,
+  iteration  INTEGER,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_context_task ON task_context(task_id);

package/migrations/003-drop-orphaned-columns.sql

@@ -0,0 +1,72 @@
+-- Migration 003: Drop orphaned columns
+-- These columns were defined but never read or written by production code
+
+-- SQLite doesn't support DROP COLUMN directly, so we need to recreate tables
+-- This migration uses the "rename-copy-drop" pattern
+
+-- ============================================================================
+-- Sessions table: drop estimated_cost and compaction_count
+-- ============================================================================
+
+CREATE TABLE sessions_new (
+  id               TEXT PRIMARY KEY,
+  agent_name       TEXT NOT NULL,
+  mode             TEXT NOT NULL CHECK(mode IN ('chat', 'task', 'daemon', 'subagent')),
+  status           TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'closed')),
+  model            TEXT,
+  token_input      INTEGER NOT NULL DEFAULT 0,
+  token_output     INTEGER NOT NULL DEFAULT 0,
+  token_cache      INTEGER NOT NULL DEFAULT 0,
+  created_at       TEXT NOT NULL,
+  updated_at       TEXT NOT NULL
+);
+
+INSERT INTO sessions_new (id, agent_name, mode, status, model, token_input, token_output, token_cache, created_at, updated_at)
+SELECT id, agent_name, mode, status, model, token_input, token_output, token_cache, created_at, updated_at
+FROM sessions;
+
+DROP TABLE sessions;
+ALTER TABLE sessions_new RENAME TO sessions;
+
+CREATE INDEX idx_sessions_agent ON sessions(agent_name);
+CREATE INDEX idx_sessions_status ON sessions(status);
+
+-- ============================================================================
+-- Tasks table: drop estimated_cost
+-- ============================================================================
+
+CREATE TABLE tasks_new (
+  id                   TEXT PRIMARY KEY,
+  agent_name           TEXT NOT NULL,
+  input                TEXT NOT NULL,
+  status               TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'processing', 'waiting', 'finished', 'failed', 'canceled')),
+  priority             TEXT NOT NULL DEFAULT 'normal' CHECK(priority IN ('low', 'normal', 'high')),
+  output               TEXT,
+  error                TEXT,
+  session_id           TEXT,
+  parent_task_id       TEXT,
+  tags                 TEXT,
+  iterations           INTEGER NOT NULL DEFAULT 0,
+  max_iterations       INTEGER,
+  max_duration_seconds INTEGER,
+  token_input          INTEGER NOT NULL DEFAULT 0,
+  token_output         INTEGER NOT NULL DEFAULT 0,
+  token_cache          INTEGER NOT NULL DEFAULT 0,
+  token_budget         INTEGER,
+  instance_folder      TEXT,
+  created_at           TEXT NOT NULL,
+  started_at           TEXT,
+  finished_at          TEXT,
+  updated_at           TEXT NOT NULL
+);
+
+INSERT INTO tasks_new (id, agent_name, input, status, priority, output, error, session_id, parent_task_id, tags, iterations, max_iterations, max_duration_seconds, token_input, token_output, token_cache, token_budget, instance_folder, created_at, started_at, finished_at, updated_at)
+SELECT id, agent_name, input, status, priority, output, error, session_id, parent_task_id, tags, iterations, max_iterations, max_duration_seconds, token_input, token_output, token_cache, token_budget, instance_folder, created_at, started_at, finished_at, updated_at
+FROM tasks;
+
+DROP TABLE tasks;
+ALTER TABLE tasks_new RENAME TO tasks;
+
+CREATE INDEX idx_tasks_agent ON tasks(agent_name);
+CREATE INDEX idx_tasks_status ON tasks(status);
+CREATE INDEX idx_tasks_parent ON tasks(parent_task_id);

package/migrations/004-session-message-token-fields.sql

@@ -0,0 +1,78 @@
+-- Migration 004: Rename token columns in sessions, add context tracking, improve message token fields
+-- Sessions: token_input/output/cache → total_input/output/cache_tokens, estimated_cost → cost
+--           + new context_size and context_size_limit columns
+-- Messages: replace single token_count with per-message model_key + input/output/cache_tokens + cost
+
+-- ============================================================================
+-- Sessions table
+-- ============================================================================
+
+CREATE TABLE sessions_new (
+  id                  TEXT PRIMARY KEY,
+  agent_name          TEXT NOT NULL,
+  mode                TEXT NOT NULL CHECK(mode IN ('chat','task','daemon','subagent')),
+  instance_folder     TEXT,
+  status              TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','closed')),
+  model               TEXT,
+  title               TEXT,
+  message_count       INTEGER NOT NULL DEFAULT 0,
+  total_input_tokens  INTEGER NOT NULL DEFAULT 0,
+  total_output_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cache_tokens  INTEGER NOT NULL DEFAULT 0,
+  context_size        INTEGER NOT NULL DEFAULT 0,
+  context_size_limit  INTEGER,
+  cost                REAL    NOT NULL DEFAULT 0,
+  compaction_count    INTEGER NOT NULL DEFAULT 0,
+  created_at          TEXT NOT NULL,
+  updated_at          TEXT NOT NULL
+);
+
+INSERT INTO sessions_new (
+  id, agent_name, mode, instance_folder, status, model, title, message_count,
+  total_input_tokens, total_output_tokens, total_cache_tokens, context_size, cost,
+  compaction_count, created_at, updated_at
+)
+SELECT
+  id, agent_name, mode, instance_folder, status, model, title, COALESCE(message_count, 0),
+  COALESCE(token_input, 0), COALESCE(token_output, 0), COALESCE(token_cache, 0),
+  0,
+  COALESCE(estimated_cost, 0),
+  COALESCE(compaction_count, 0),
+  created_at, updated_at
+FROM sessions;
+
+DROP TABLE sessions;
+ALTER TABLE sessions_new RENAME TO sessions;
+
+CREATE INDEX idx_sessions_agent   ON sessions(agent_name);
+CREATE INDEX idx_sessions_status  ON sessions(status);
+CREATE INDEX idx_sessions_created ON sessions(created_at);
+CREATE INDEX idx_sessions_folder  ON sessions(instance_folder);
+
+-- ============================================================================
+-- Messages table
+-- ============================================================================
+
+CREATE TABLE messages_new (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id   TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  role         TEXT NOT NULL CHECK(role IN ('system','user','assistant','tool')),
+  content      TEXT,
+  tool_calls   TEXT,
+  tool_call_id TEXT,
+  model_key    TEXT,
+  input_tokens  INTEGER,
+  output_tokens INTEGER,
+  cache_tokens  INTEGER,
+  cost          REAL,
+  created_at   TEXT NOT NULL
+);
+
+INSERT INTO messages_new (id, session_id, role, content, tool_calls, tool_call_id, output_tokens, created_at)
+SELECT id, session_id, role, content, tool_calls, tool_call_id, token_count, created_at
+FROM messages;
+
+DROP TABLE messages;
+ALTER TABLE messages_new RENAME TO messages;
+
+CREATE INDEX idx_messages_session ON messages(session_id);

package/migrations/005-session-thinking.sql

@@ -0,0 +1,5 @@
+-- Migration 005: Add model_thinking column to sessions
+-- Stores an optional JSON config for extended thinking mode (e.g. Anthropic extended thinking).
+-- Can be set at session creation time to override the agent's default thinking config.
+
+ALTER TABLE sessions ADD COLUMN model_thinking TEXT;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@newsails/veil-cli",
+  "version": "1.0.1",
+  "description": "VeilCLI - Enterprise autonomous agent runtime — local, API-first, multi-model",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.3.0"
+  },
+  "bin": {
+    "veil": "./cli/index.js"
+  },
+  "scripts": {
+    "start": "node cli/index.js start",
+    "test": "node test/smoke.js",
+    "test:smoke": "node test/smoke.js",
+    "test:integration": "node test/runner.js",
+    "test:integration:quick": "node test/runner.js --quick",
+    "test:all": "node test/smoke.js && node test/runner.js",
+    "fetch-models": "node scripts/fetch-models.js"
+  },
+  "dependencies": {
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1",
+    "better-sqlite3": "11.10.0",
+    "cors": "2.8.5",
+    "express": "4.21.2",
+    "node-cron": "3.0.3",
+    "ws": "^8.19.0"
+  }
+}

package/schemas/agent.json

@@ -0,0 +1,143 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "VeilCLI Agent Configuration",
+  "type": "object",
+  "required": ["name", "model"],
+  "additionalProperties": false,
+  "properties": {
+    "name": { "type": "string", "minLength": 1 },
+    "description": { "type": "string" },
+    "model": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Model identifier string e.g. 'anthropic/claude-3.5-sonnet'. Must be a string, NOT an object."
+    },
+    "temperature": { "type": "number", "minimum": 0, "maximum": 2 },
+    "reasoning": { "type": "string" },
+    "maxTokens": { "type": "integer", "minimum": 1 },
+    "memory": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "maxLines": { "type": "integer", "minimum": 10 }
+      }
+    },
+    "skillDiscovery": { "type": "boolean" },
+    "modes": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "chat": { "$ref": "#/definitions/chatModeConfig" },
+        "task": { "$ref": "#/definitions/taskModeConfig" },
+        "subagent": { "$ref": "#/definitions/subagentModeConfig" },
+        "daemon": { "$ref": "#/definitions/daemonModeConfig" }
+      }
+    }
+  },
+  "definitions": {
+    "permissionsConfig": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "allow": { "type": "array", "items": { "type": "string" } },
+        "deny": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "baseModeConfig": {
+      "type": "object",
+      "required": ["enabled"],
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "tools": { "type": "array", "items": { "type": "string" } },
+        "disallowedTools": { "type": "array", "items": { "type": "string" } },
+        "skills": { "type": "array", "items": { "type": "string" } },
+        "autoLoadSkills": { "type": "array", "items": { "type": "string" } },
+        "mcpServers": { "type": "array", "items": { "type": "string" } },
+        "allowedAgents": { "type": "array", "items": { "type": "string" } },
+        "disallowedAgents": { "type": "array", "items": { "type": "string" } },
+        "permissions": { "$ref": "#/definitions/permissionsConfig" }
+      }
+    },
+    "chatModeConfig": {
+      "allOf": [{ "$ref": "#/definitions/baseModeConfig" }],
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "tools": { "type": "array", "items": { "type": "string" } },
+        "disallowedTools": { "type": "array", "items": { "type": "string" } },
+        "skills": { "type": "array", "items": { "type": "string" } },
+        "autoLoadSkills": { "type": "array", "items": { "type": "string" } },
+        "mcpServers": { "type": "array", "items": { "type": "string" } },
+        "allowedAgents": { "type": "array", "items": { "type": "string" } },
+        "disallowedAgents": { "type": "array", "items": { "type": "string" } },
+        "permissions": { "$ref": "#/definitions/permissionsConfig" }
+      }
+    },
+    "taskModeConfig": {
+      "type": "object",
+      "required": ["enabled"],
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "tools": { "type": "array", "items": { "type": "string" } },
+        "disallowedTools": { "type": "array", "items": { "type": "string" } },
+        "skills": { "type": "array", "items": { "type": "string" } },
+        "autoLoadSkills": { "type": "array", "items": { "type": "string" } },
+        "mcpServers": { "type": "array", "items": { "type": "string" } },
+        "allowedAgents": { "type": "array", "items": { "type": "string" } },
+        "disallowedAgents": { "type": "array", "items": { "type": "string" } },
+        "permissions": { "$ref": "#/definitions/permissionsConfig" },
+        "maxIterations": { "type": "integer", "minimum": 1 },
+        "maxDurationSeconds": { "type": "integer", "minimum": 1 },
+        "onExhausted": { "type": "string", "enum": ["fail", "wait"] }
+      }
+    },
+    "subagentModeConfig": {
+      "type": "object",
+      "required": ["enabled"],
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "tools": { "type": "array", "items": { "type": "string" } },
+        "disallowedTools": { "type": "array", "items": { "type": "string" } },
+        "skills": { "type": "array", "items": { "type": "string" } },
+        "autoLoadSkills": { "type": "array", "items": { "type": "string" } },
+        "mcpServers": { "type": "array", "items": { "type": "string" } },
+        "allowedAgents": { "type": "array", "items": { "type": "string" } },
+        "disallowedAgents": { "type": "array", "items": { "type": "string" } },
+        "permissions": { "$ref": "#/definitions/permissionsConfig" },
+        "maxIterations": { "type": "integer", "minimum": 1 },
+        "maxDurationSeconds": { "type": "integer", "minimum": 1 }
+      }
+    },
+    "daemonModeConfig": {
+      "type": "object",
+      "required": ["enabled"],
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "tools": { "type": "array", "items": { "type": "string" } },
+        "disallowedTools": { "type": "array", "items": { "type": "string" } },
+        "skills": { "type": "array", "items": { "type": "string" } },
+        "autoLoadSkills": { "type": "array", "items": { "type": "string" } },
+        "mcpServers": { "type": "array", "items": { "type": "string" } },
+        "allowedAgents": { "type": "array", "items": { "type": "string" } },
+        "disallowedAgents": { "type": "array", "items": { "type": "string" } },
+        "permissions": { "$ref": "#/definitions/permissionsConfig" },
+        "cron": { "type": "string" },
+        "maxIterations": { "type": "integer", "minimum": 1 },
+        "maxDurationSeconds": { "type": "integer", "minimum": 1 },
+        "conflictPolicy": { "type": "string", "enum": ["skip", "queue", "restart"] },
+        "alertRouting": {
+          "oneOf": [
+            { "type": "string" },
+            { "type": "array", "items": { "type": "string" } }
+          ]
+        },
+        "heartbeatFile": { "type": "string" }
+      }
+    }
+  }
+}