@newsails/veil-cli 1.0.1

package/tools/task_create.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'task_create',
+  description: 'Create a new task for any agent. The task runs asynchronously. Use task_status to check progress.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      agent: { type: 'string', description: 'Name of the agent to run the task' },
+      input: { type: 'string', description: 'Task input / instructions' },
+      priority: { type: 'string', enum: ['high', 'normal', 'low'], description: 'Task priority (default: normal)' },
+      tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags for filtering' },
+      maxIterations: { type: 'integer', description: 'Override max iterations for this task', minimum: 1 },
+      maxDurationSeconds: { type: 'integer', description: 'Override max duration in seconds', minimum: 1 },
+    },
+    required: ['agent', 'input'],
+  },
+  timeout: 5,
+};
+
+async function execute({ agent, input, priority = 'normal', tags, maxIterations, maxDurationSeconds, _cwd, _taskId }) {
+  const taskId = db.createTask({
+    agentName: agent,
+    input,
+    priority,
+    tags,
+    maxIterations,
+    maxDurationSeconds,
+    parentTaskId: _taskId || null,
+    instanceFolder: _cwd,
+  });
+
+  // Auto-subscribe the calling task to this new task's completion
+  // (done by the task runner when it picks up the task)
+
+  return JSON.stringify({ taskId, status: 'pending', agent, message: 'Task created. Use task_status to check progress.' });
+}
+
+module.exports = { schema, execute };

package/tools/task_respond.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'task_respond',
+  description: 'Respond to a task that is waiting for input (task mode only). Resumes the paused task with your message.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      taskId: { type: 'string', description: 'Task ID that is waiting' },
+      message: { type: 'string', description: 'Response message to send to the waiting task' },
+    },
+    required: ['taskId', 'message'],
+  },
+  timeout: 5,
+};
+
+async function execute({ taskId, message }) {
+  const task = db.getTask(taskId);
+  if (!task) return `Task not found: ${taskId}`;
+  if (task.status !== 'waiting') return `Task ${taskId} is not waiting (status: ${task.status})`;
+
+  db.enqueueAgentMessage({
+    targetAgent: task.agent_name,
+    fromAgent: 'user',
+    content: message,
+    followup: false,
+  });
+
+  db.updateTask(taskId, { status: 'processing' });
+  db.addTaskEvent({ taskId, type: 'status.change', data: { from: 'waiting', to: 'processing', reason: 'task_respond' } });
+
+  return `Response sent to task ${taskId}. Task resumed.`;
+}
+
+module.exports = { schema, execute };

package/tools/task_spawn.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'task_spawn',
+  description: 'Spawn a sub-agent task with an isolated context. Sync (wait:true, default) or async (wait:false for parallel fan-out). Returns task result or taskId.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      agent: { type: 'string', description: 'Name of the agent to spawn a task for' },
+      instruction: { type: 'string', description: 'Instruction for the sub-agent. Use "/skill-name args" to trigger a skill.' },
+      returnMode: { type: 'string', enum: ['summary', 'raw', 'lastMessage'], description: 'How to return results (default: summary)' },
+      wait: { type: 'boolean', description: 'true=sync (wait for result), false=async (returns taskId immediately). Default: true' },
+    },
+    required: ['agent', 'instruction'],
+  },
+  timeout: 86400,
+};
+
+async function execute({ agent, instruction, returnMode = 'summary', wait = true, _cwd, _taskId, _sessionId, _settings, _agent: callerAgent }) {
+  const taskId = db.createTask({
+    agentName: agent,
+    input: instruction,
+    priority: 'normal',
+    parentTaskId: _taskId || null,
+    instanceFolder: _cwd,
+  });
+
+  // Auto-subscribe caller to this task's completion
+  if (_sessionId) {
+    db.createTaskSubscription({
+      taskId,
+      subscriberSessionId: _sessionId,
+      subscriberAgent: callerAgent?.name || 'unknown',
+    });
+  }
+
+  db.addTaskEvent({ taskId, type: 'status.change', data: { from: 'pending', to: 'pending', reason: 'task_spawn' } });
+
+  if (!wait) {
+    return JSON.stringify({ taskId, status: 'pending', agent, message: 'Task spawned async. Use task_status to check.' });
+  }
+
+  // Sync: run the subagent inline using the router
+  try {
+    const { runSubagent } = require('../core/router');
+    const result = await runSubagent({ taskId, cwd: _cwd, settings: _settings });
+    const task = db.getTask(taskId);
+
+    if (returnMode === 'raw') {
+      return JSON.stringify({ taskId, status: task.status, output: task.output });
+    }
+    if (returnMode === 'lastMessage') {
+      return task.output || '(no output)';
+    }
+    // summary (default) — return output directly
+    return task.output || `Sub-agent ${agent} completed with no output`;
+  } catch (err) {
+    return `Task error: ${err.message}`;
+  }
+}
+
+module.exports = { schema, execute };

package/tools/task_status.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'task_status',
+  description: 'Check the status and output of a task.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      taskId: { type: 'string', description: 'Task ID to check' },
+    },
+    required: ['taskId'],
+  },
+  timeout: 5,
+};
+
+async function execute({ taskId }) {
+  const task = db.getTask(taskId);
+  if (!task) return `Task not found: ${taskId}`;
+
+  const result = {
+    taskId: task.id,
+    status: task.status,
+    agent: task.agent_name,
+    iterations: task.iterations,
+    createdAt: task.created_at,
+    updatedAt: task.updated_at,
+  };
+
+  if (task.status === 'finished') result.output = task.output;
+  if (task.status === 'failed') result.error = task.error;
+  if (task.started_at) result.startedAt = task.started_at;
+  if (task.finished_at) result.finishedAt = task.finished_at;
+
+  return JSON.stringify(result, null, 2);
+}
+
+module.exports = { schema, execute };

package/tools/task_subscribe.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'task_subscribe',
+  description: 'Subscribe to a task\'s completion. For external observers — own spawned tasks auto-subscribe. Subscription is durable (survives session closure).',
+  input_schema: {
+    type: 'object',
+    properties: {
+      taskId: { type: 'string', description: 'Task ID to subscribe to' },
+    },
+    required: ['taskId'],
+  },
+  timeout: 5,
+};
+
+async function execute({ taskId, _sessionId, _agent: callerAgent }) {
+  const task = db.getTask(taskId);
+  if (!task) return `Task not found: ${taskId}`;
+
+  if (task.status === 'finished' || task.status === 'failed' || task.status === 'canceled') {
+    return JSON.stringify({ taskId, status: task.status, message: 'Task already completed — no subscription needed' });
+  }
+
+  if (_sessionId) {
+    db.createTaskSubscription({
+      taskId,
+      subscriberSessionId: _sessionId,
+      subscriberAgent: callerAgent?.name || 'unknown',
+    });
+  }
+
+  return JSON.stringify({ taskId, subscribed: true, message: `Subscribed to task ${taskId}. You will be notified on completion.` });
+}
+
+module.exports = { schema, execute };

package/tools/todo_read.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'todo_read',
+  description: 'Read the current TODO list for the active session.',
+  input_schema: {
+    type: 'object',
+    properties: {},
+  },
+  timeout: 5,
+};
+
+async function execute({ _sessionId }) {
+  if (!_sessionId) return 'No active session';
+  const todos = db.getTodos(_sessionId);
+  if (todos.length === 0) return 'No TODOs yet. Use todo_write to create a plan.';
+  const lines = todos.map(t => {
+    const check = t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '~' : ' ';
+    return `- [${check}] [${t.priority}] ${t.content}`;
+  });
+  return `Current TODOs (${todos.length}):\n${lines.join('\n')}`;
+}
+
+module.exports = { schema, execute };

package/tools/todo_write.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const db = require('../infrastructure/database');
+
+const schema = {
+  name: 'todo_write',
+  description: 'Create or update a structured TODO list that survives context compaction.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      todos: {
+        type: 'array',
+        description: 'Full list of todo items (replaces existing list)',
+        items: {
+          type: 'object',
+          required: ['id', 'content', 'status', 'priority'],
+          properties: {
+            id: { type: 'string' },
+            content: { type: 'string' },
+            status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+            priority: { type: 'string', enum: ['high', 'medium', 'low'] },
+          },
+        },
+      },
+    },
+    required: ['todos'],
+  },
+  timeout: 5,
+};
+
+async function execute({ todos, _sessionId }) {
+  if (!_sessionId) return 'No active session for todos';
+  db.saveTodos(_sessionId, todos);
+  const summary = todos.map(t => `- [${t.status === 'completed' ? 'x' : ' '}] ${t.content}`).join('\n');
+  return `TODOs saved (${todos.length} items):\n${summary}`;
+}
+
+module.exports = { schema, execute };

package/tools/tool_activate.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const registry = require('../core/registry');
+
+const schema = {
+  name: 'tool_activate',
+  description: 'Make a custom tool callable by loading its full schema into the active tools list. Call this after tool_search once you have decided to use a specific custom tool.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Exact tool name to activate (as returned by tool_search)' },
+    },
+    required: ['name'],
+  },
+  timeout: 5,
+};
+
+async function execute({ name, _agent, _cwd }) {
+  const tool = registry.resolveTool({ name, agentConfig: _agent, cwd: _cwd });
+  if (!tool) return `Tool "${name}" not found. Use tool_search to discover available tools.`;
+  return JSON.stringify({ activated: name });
+}
+
+module.exports = { schema, execute };

package/tools/tool_search.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const registry = require('../core/registry');
+
+const schema = {
+  name: 'tool_search',
+  description: 'Search available tools by name or description. Returns full schemas for matching tools (Tier 3 loading).',
+  input_schema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query (tool name or description keyword)' },
+    },
+    required: ['query'],
+  },
+  timeout: 5,
+};
+
+async function execute({ query, _agent, _cwd }) {
+  const results = registry.searchTools({ query, agentConfig: _agent, cwd: _cwd });
+  if (results.length === 0) return `No tools found matching: ${query}`;
+  return JSON.stringify(results, null, 2);
+}
+
+module.exports = { schema, execute };

package/tools/web_fetch.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const schema = {
+  name: 'web_fetch',
+  description: 'Fetch content from a URL. Returns text, JSON, or base64 for images.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'URL to fetch' },
+      mode: { type: 'string', enum: ['text', 'json', 'base64'], description: 'Response format (default: text)' },
+    },
+    required: ['url'],
+  },
+  timeout: 30,
+};
+
+async function execute({ url, mode = 'text' }) {
+  const response = await fetch(url, {
+    headers: { 'User-Agent': 'VeilCLI/1.0' },
+  });
+
+  if (!response.ok) {
+    return `HTTP ${response.status}: ${response.statusText} for ${url}`;
+  }
+
+  if (mode === 'json') {
+    const data = await response.json();
+    return JSON.stringify(data, null, 2);
+  }
+
+  if (mode === 'base64') {
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer).toString('base64');
+  }
+
+  // text mode — strip HTML tags for cleaner output
+  let text = await response.text();
+  const contentType = response.headers.get('content-type') || '';
+  if (contentType.includes('text/html')) {
+    text = text
+      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/\s{2,}/g, ' ')
+      .trim();
+  }
+  return text.slice(0, 50000); // cap at 50KB
+}
+
+module.exports = { schema, execute };

package/tools/web_search.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const schema = {
+  name: 'web_search',
+  description: 'Search the web and return a list of results with titles, URLs, and snippets.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      numResults: { type: 'integer', description: 'Number of results to return (default: 5, max: 10)', minimum: 1, maximum: 10 },
+    },
+    required: ['query'],
+  },
+  timeout: 15,
+};
+
+async function execute({ query, numResults = 5 }) {
+  // Using DuckDuckGo HTML search as a no-auth fallback
+  const encoded = encodeURIComponent(query);
+  const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+
+  try {
+    const response = await fetch(url, {
+      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; VeilCLI/1.0)' },
+    });
+
+    if (!response.ok) return `Search failed: HTTP ${response.status}`;
+
+    const html = await response.text();
+
+    // Parse results from DDG HTML
+    const resultRegex = /<a class="result__a" href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    const results = [];
+    let match;
+
+    while ((match = resultRegex.exec(html)) !== null && results.length < numResults) {
+      const url = match[1];
+      const title = match[2].replace(/<[^>]+>/g, '').trim();
+      const snippet = match[3].replace(/<[^>]+>/g, '').trim();
+      if (url && title) {
+        results.push(`${results.length + 1}. **${title}**\n   URL: ${url}\n   ${snippet}`);
+      }
+    }
+
+    if (results.length === 0) return `No results found for: ${query}`;
+    return `Search results for "${query}":\n\n${results.join('\n\n')}`;
+  } catch (err) {
+    return `Search error: ${err.message}`;
+  }
+}
+
+module.exports = { schema, execute };

package/tools/write_file.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const schema = {
+  name: 'write_file',
+  description: 'Write or overwrite an entire file. Creates parent directories if needed. Prefer edit_file for modifications to existing files.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      file: { type: 'string', description: 'Path to the file (relative to cwd or absolute)' },
+      content: { type: 'string', description: 'Full content to write to the file' },
+    },
+    required: ['file', 'content'],
+  },
+  timeout: 10,
+};
+
+async function execute({ file, content, _cwd }) {
+  const filePath = path.isAbsolute(file) ? file : path.resolve(_cwd, file);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, 'utf8');
+  const lines = content.split('\n').length;
+  return `Written ${lines} lines to ${filePath}`;
+}
+
+module.exports = { schema, execute };

package/ui/api.js

@@ -0,0 +1,190 @@
+'use strict';
+
+window.Veil = window.Veil || {};
+
+window.Veil.API = class API {
+  constructor(baseUrl, secret) {
+    this.baseUrl = (baseUrl || '').replace(/\/+$/, '');
+    this.secret  = secret || '';
+  }
+
+  _headers(extra) {
+    const h = Object.assign({ 'Content-Type': 'application/json' }, extra);
+    if (this.secret) h['X-Veil-Secret'] = this.secret;
+    return h;
+  }
+
+  async _fetch(method, path, body) {
+    const opts = { method, headers: this._headers() };
+    if (body !== undefined) opts.body = JSON.stringify(body);
+    let res;
+    try {
+      res = await fetch(this.baseUrl + path, opts);
+    } catch (err) {
+      const e = new Error('Network error: ' + err.message);
+      e.status = 0; throw e;
+    }
+    const ct = res.headers.get('content-type') || '';
+    if (!res.ok) {
+      let errBody;
+      try { errBody = ct.includes('json') ? await res.json() : await res.text(); }
+      catch { errBody = 'HTTP ' + res.status; }
+      const msg = typeof errBody === 'object'
+        ? (errBody.error || errBody.message || JSON.stringify(errBody))
+        : (errBody || 'HTTP ' + res.status);
+      const e = new Error(msg);
+      e.status = res.status; e.body = errBody; throw e;
+    }
+    if (ct.includes('json')) return res.json();
+    return res.text();
+  }
+
+  get(path)           { return this._fetch('GET',    path); }
+  post(path, body)    { return this._fetch('POST',   path, body); }
+  put(path, body)     { return this._fetch('PUT',    path, body); }
+  delete(path)        { return this._fetch('DELETE', path); }
+
+  /* SSE helper: splits chunks on \n\n event boundaries */
+  async _readSSE(response, onEvent) {
+    const reader  = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const parts = buf.split('\n\n');
+      buf = parts.pop();
+      for (const block of parts) {
+        if (!block.trim()) continue;
+        let type = null, data = null;
+        for (const line of block.split('\n')) {
+          if (line.startsWith('event: '))      type = line.slice(7).trim();
+          else if (line.startsWith('data: '))  data = line.slice(6).trim();
+        }
+        if (type && data) {
+          try { onEvent(type, JSON.parse(data)); } catch {}
+        }
+      }
+    }
+  }
+
+  /* Chat SSE stream */
+  async chatStream(agentName, body, cbs) {
+    const { onChunk, onToolName, onMessage, onDone, onError } = cbs;
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}/agents/${encodeURIComponent(agentName)}/chat`, {
+        method: 'POST', headers: this._headers(),
+        body: JSON.stringify(Object.assign({}, body, { sse: true })),
+      });
+    } catch (err) { onError && onError({ error: err.message }); return; }
+    if (!res.ok) {
+      let b; try { b = await res.json(); } catch { b = { error: 'HTTP ' + res.status }; }
+      onError && onError(b); return;
+    }
+    await this._readSSE(res, (type, data) => {
+      if      (type === 'inference.chunk') onChunk    && onChunk(data);
+      else if (type === 'inference.tool')  onToolName && onToolName(data);
+      else if (type === 'message')         onMessage  && onMessage(data);
+      else if (type === 'done')            onDone     && onDone(data);
+      else if (type === 'error')           onError    && onError(data);
+    });
+  }
+
+  /* Task SSE stream — returns { close } */
+  taskStream(taskId, cbs) {
+    const { onStatus, onEvent, onError } = cbs;
+    const ctrl = new AbortController();
+    fetch(`${this.baseUrl}/tasks/${encodeURIComponent(taskId)}/stream`, {
+      headers: this._headers(), signal: ctrl.signal,
+    }).then(async res => {
+      if (!res.ok) { onError && onError('HTTP ' + res.status); return; }
+      await this._readSSE(res, (type, data) => {
+        if      (type === 'status') onStatus && onStatus(data);
+        else if (type === 'task')   onEvent  && onEvent(data);
+      });
+    }).catch(err => { if (err.name !== 'AbortError') onError && onError(err.message); });
+    return { close: () => ctrl.abort() };
+  }
+
+  /* WebSocket */
+  connectWS(onMessage, onOpen, onClose) {
+    const wsUrl = this.baseUrl.replace(/^http/, 'ws') + '/ws'
+      + (this.secret ? '?secret=' + encodeURIComponent(this.secret) : '');
+    const ws = new WebSocket(wsUrl);
+    ws.onopen  = ()  => onOpen && onOpen();
+    ws.onclose = ()  => onClose && onClose();
+    ws.onerror = ()  => ws.close();
+    ws.onmessage = e => { try { onMessage && onMessage(JSON.parse(e.data)); } catch {} };
+    return ws;
+  }
+
+  /* ── System ─────────────────────────────────────────────── */
+  health() { return this.get('/health'); }
+  status() { return this.get('/status'); }
+
+  /* ── Agents ─────────────────────────────────────────────── */
+  listAgents()              { return this.get('/agents'); }
+  getAgent(name)            { return this.get(`/agents/${encodeURIComponent(name)}`); }
+  createAgent(body)         { return this.post('/agents', body); }
+  updateAgent(name, body)   { return this.put(`/agents/${encodeURIComponent(name)}`, body); }
+  deleteAgent(name)         { return this.delete(`/agents/${encodeURIComponent(name)}`); }
+  reloadAgent(name)         { return this.post(`/agents/${encodeURIComponent(name)}/reload`, {}); }
+  getAgentSkills(name)      { return this.get(`/agents/${encodeURIComponent(name)}/skills`); }
+  getAgentSessions(name, p) {
+    const q = p ? '?' + new URLSearchParams(p) : '';
+    return this.get(`/agents/${encodeURIComponent(name)}/sessions${q}`);
+  }
+  getAgentTasks(name, p) {
+    const q = p ? '?' + new URLSearchParams(p) : '';
+    return this.get(`/agents/${encodeURIComponent(name)}/tasks${q}`);
+  }
+  getAgentMemory(name)              { return this.get(`/agents/${encodeURIComponent(name)}/memory`); }
+  getAgentMemoryFile(name, file)    { return this.get(`/agents/${encodeURIComponent(name)}/memory/${encodeURIComponent(file)}`); }
+  putAgentMemoryFile(name, file, c) { return this.put(`/agents/${encodeURIComponent(name)}/memory/${encodeURIComponent(file)}`, { content: c }); }
+  deleteAgentMemoryFile(name, file) { return this.delete(`/agents/${encodeURIComponent(name)}/memory/${encodeURIComponent(file)}`); }
+
+  /* ── Chat ───────────────────────────────────────────────── */
+  chat(agentName, message, sessionId) {
+    const body = { message };
+    if (sessionId) body.sessionId = sessionId;
+    return this.post(`/agents/${encodeURIComponent(agentName)}/chat`, body);
+  }
+
+  /* ── Tasks ──────────────────────────────────────────────── */
+  createTask(agentName, body)    { return this.post(`/agents/${encodeURIComponent(agentName)}/task`, body); }
+  listTasks(p)                   { const q = p ? '?' + new URLSearchParams(p) : ''; return this.get(`/tasks${q}`); }
+  getTask(id)                    { return this.get(`/tasks/${encodeURIComponent(id)}`); }
+  getTaskEvents(id, since)       { return this.get(`/tasks/${encodeURIComponent(id)}/events?since=${since || 0}`); }
+  cancelTask(id)                 { return this.post(`/tasks/${encodeURIComponent(id)}/cancel`, {}); }
+  respondTask(id, message)       { return this.post(`/tasks/${encodeURIComponent(id)}/respond`, { message }); }
+  deleteTask(id, force)          { return this.delete(`/tasks/${encodeURIComponent(id)}${force ? '?force=true' : ''}`); }
+
+  /* ── Sessions ───────────────────────────────────────────── */
+  listSessions(p)               { const q = p ? '?' + new URLSearchParams(p) : ''; return this.get(`/sessions${q}`); }
+  getSession(id)                { return this.get(`/sessions/${encodeURIComponent(id)}`); }
+  getSessionMessages(id, p)     { const q = p ? '?' + new URLSearchParams(p) : ''; return this.get(`/sessions/${encodeURIComponent(id)}/messages${q}`); }
+  resetSession(id)              { return this.post(`/sessions/${encodeURIComponent(id)}/reset`, {}); }
+  deleteSession(id, hard)       { return this.delete(`/sessions/${encodeURIComponent(id)}${hard ? '?hard=true' : ''}`); }
+
+  /* ── Daemons ────────────────────────────────────────────── */
+  listDaemons()        { return this.get('/daemons'); }
+  startDaemon(name)    { return this.post(`/agents/${encodeURIComponent(name)}/daemon/start`, {}); }
+  stopDaemon(name)     { return this.post(`/agents/${encodeURIComponent(name)}/daemon/stop`, {}); }
+  triggerDaemon(name)  { return this.post(`/agents/${encodeURIComponent(name)}/daemon/trigger`, {}); }
+
+  /* ── Memory (global) ────────────────────────────────────── */
+  listMemory()           { return this.get('/memory'); }
+  getMemoryFile(file)    { return this.get(`/memory/${encodeURIComponent(file)}`); }
+  putMemoryFile(file, c) { return this.put(`/memory/${encodeURIComponent(file)}`, { content: c }); }
+  deleteMemoryFile(file) { return this.delete(`/memory/${encodeURIComponent(file)}`); }
+
+  /* ── Settings ───────────────────────────────────────────── */
+  getSettings(level)      { return this.get(`/settings?level=${level || 'merged'}`); }
+  putSettings(body, level){ return this.put(`/settings?level=${level || 'project'}`, body); }
+
+  /* ── Models ─────────────────────────────────────────────── */
+  listModels()    { return this.get('/models'); }
+  refreshModels() { return this.post('/models/refresh', {}); }
+};