@ducci/jarvis 1.0.38 → 1.0.39

package/src/server/app.js

@@ -2,10 +2,11 @@ import express from 'express';
 import path from 'path';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
-import { realpathSync } from 'fs';
-import { loadConfig, ensureDirectories } from './config.js';
+import fs, { realpathSync, existsSync, writeFileSync } from 'fs';
+import { loadConfig, ensureDirectories, PATHS } from './config.js';
 import { seedTools } from './tools.js';
 import { handleChat } from './agent.js';
+import { initCrons } from './crons.js';
 import { startTelegramChannel } from '../channels/telegram/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -58,6 +59,125 @@ app.use((req, res, next) => {
   }
 });
 
+const DEFAULT_IDENTITY = `# Identity
+
+You are Jarvis, a fully autonomous agent running on a local server. You have access to tools and can execute shell commands on the machine you run on.
+
+Be concise and direct in your responses. Avoid unnecessary filler. When a task is done, say so clearly.
+`;
+
+function seedIdentity() {
+  if (!existsSync(PATHS.identityFile)) {
+    writeFileSync(PATHS.identityFile, DEFAULT_IDENTITY, 'utf8');
+    console.log('Created default identity.md');
+  }
+}
+
+const EXAMPLE_SKILL_MD = `---
+name: add-two-integers
+description: Adds two integer numbers by running a Node.js script
+---
+
+# Add Two Integers
+
+Use this skill when asked to add two integer numbers.
+
+## How to use
+
+Run the bundled script via \`exec\` with two integer arguments:
+
+\`\`\`sh
+node ~/.jarvis/data/skills/add-two-integers/add.js <a> <b>
+\`\`\`
+
+Example:
+
+\`\`\`sh
+node ~/.jarvis/data/skills/add-two-integers/add.js 3 7
+# Output: 10
+\`\`\`
+
+Both arguments must be integers. The script exits with code 1 and prints a usage error if either argument is missing or not a valid integer.
+`;
+
+const EXAMPLE_SKILL_JS = `const a = parseInt(process.argv[2], 10);
+const b = parseInt(process.argv[3], 10);
+
+if (isNaN(a) || isNaN(b)) {
+  console.error('Usage: node add.js <integer_a> <integer_b>');
+  process.exit(1);
+}
+
+console.log(a + b);
+`;
+
+const MANAGE_SKILL_MD = `---
+name: manage-skill
+description: Create, edit, or delete a skill in ~/.jarvis/data/skills/. Use this when the user asks to add a new skill, update an existing skill, or remove a skill.
+---
+
+# Manage Skill
+
+Use this skill when the user asks to create, list, edit, or delete a skill.
+
+## What makes a good skill
+
+- A skill describes a **workflow or approach**, not a single command
+- The name is specific and lowercase with hyphens (e.g. \`scan-open-ports\`, not \`scanning\`)
+- The description (frontmatter) is the **only signal the agent has to decide whether to load the skill**. Write it so the agent reliably recognises when this skill applies: be specific about the task type, not just the topic, and include when to use it. Bad: "Manages ports." Good: "Scan a target host for open ports using nmap and return a structured report. Use this when the user asks to scan ports or check what services are running on a host."
+- Instructions are written for the agent, not the user — be explicit about which tools to use
+- If the skill needs a script, bundle it in the same folder and reference it by absolute path using \`~/.jarvis/data/skills/<name>/script.js\`
+- Prefer \`write_file\` over \`exec+echo\` for writing any file
+
+## Folder structure
+
+\`\`\`
+~/.jarvis/data/skills/<name>/
+  skill.md       ← required
+  *.js / *.sh    ← optional bundled scripts
+\`\`\`
+
+## Frontmatter format
+
+\`\`\`yaml
+---
+name: skill-name
+description: Description that reliably tells the agent when to use this skill
+---
+\`\`\`
+
+## Create a skill
+
+1. Create the folder: \`exec\` → \`mkdir -p ~/.jarvis/data/skills/<name>\`
+2. Write \`skill.md\` with frontmatter + instructions using \`write_file\`
+3. If scripts are needed, write them with \`write_file\` into the same folder
+
+## Edit a skill
+
+1. Read current content: \`exec\` → \`cat ~/.jarvis/data/skills/<name>/skill.md\`
+2. Overwrite with updated content using \`write_file\`
+
+## Delete a skill
+
+1. Confirm the skill name with the user before deleting
+2. \`exec\` → \`rm -rf ~/.jarvis/data/skills/<name>\`
+`;
+
+function seedSkills() {
+  const skills = [
+    { dir: 'add-two-integers', files: { 'skill.md': EXAMPLE_SKILL_MD, 'add.js': EXAMPLE_SKILL_JS } },
+    { dir: 'manage-skill', files: { 'skill.md': MANAGE_SKILL_MD } },
+  ];
+  for (const skill of skills) {
+    const skillDir = path.join(PATHS.skillsDir, skill.dir);
+    fs.mkdirSync(skillDir, { recursive: true });
+    for (const [filename, content] of Object.entries(skill.files)) {
+      const filePath = path.join(skillDir, filename);
+      if (!existsSync(filePath)) writeFileSync(filePath, content, 'utf8');
+    }
+  }
+}
+
 function startServer() {
   let config;
   try {
@@ -69,6 +189,9 @@ function startServer() {
 
   ensureDirectories();
   seedTools();
+  seedIdentity();
+  seedSkills();
+  initCrons(config);
 
   app.locals.config = config;
 

package/src/server/config.js

@@ -19,6 +19,9 @@ export const PATHS = {
   toolsFile: path.join(JARVIS_DIR, 'data', 'tools', 'tools.json'),
   logsDir: path.join(JARVIS_DIR, 'logs'),
   userInfoFile: path.join(JARVIS_DIR, 'data', 'user-info.json'),
+  identityFile: path.join(JARVIS_DIR, 'data', 'identity.md'),
+  skillsDir: path.join(JARVIS_DIR, 'data', 'skills'),
+  cronsFile: path.join(JARVIS_DIR, 'data', 'crons.json'),
   systemPromptFile: path.join(__dirname, '..', '..', 'docs', 'system-prompt.md'),
 };
 
@@ -54,6 +57,7 @@ export function loadConfig() {
     fallbackModel: settings.fallbackModel || (provider === 'anthropic' ? 'claude-haiku-4-5-20251001' : 'openrouter/free'),
     maxIterations: settings.maxIterations || 10,
     maxHandoffs: settings.maxHandoffs || 5,
+    contextWindow: settings.contextWindow || 100,
     port: settings.port || 18008,
     telegram: {
       token: process.env.TELEGRAM_BOT_TOKEN || null,
@@ -69,7 +73,43 @@ export function loadSystemPrompt() {
   return match[1].trim();
 }
 
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const meta = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length) meta[key.trim()] = rest.join(':').trim();
+  }
+  return meta;
+}
+
 export function resolveSystemPrompt(promptTemplate, sessionId) {
+  let identity = '';
+  try {
+    identity = fs.readFileSync(PATHS.identityFile, 'utf8').trim();
+  } catch {
+    // File doesn't exist yet
+  }
+
+  let skillsList = '(none)';
+  try {
+    const entries = fs.readdirSync(PATHS.skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(PATHS.skillsDir, entry.name, 'skill.md');
+      try {
+        const content = fs.readFileSync(skillFile, 'utf8');
+        const meta = parseSkillFrontmatter(content);
+        if (meta?.name && meta?.description) {
+          skills.push(`- ${meta.name}: ${meta.description}`);
+        }
+      } catch { /* skip malformed skills */ }
+    }
+    if (skills.length > 0) skillsList = skills.join('\n');
+  } catch { /* skills dir doesn't exist yet */ }
+
   let userInfo = '(none yet)';
   try {
     const raw = fs.readFileSync(PATHS.userInfoFile, 'utf8');
@@ -80,7 +120,10 @@ export function resolveSystemPrompt(promptTemplate, sessionId) {
   } catch {
     // File doesn't exist yet
   }
+
   return promptTemplate
+    .replace('{{identity}}', identity)
+    .replace('{{skills}}', skillsList)
     .replace('{{session_id}}', sessionId || 'unknown')
     .replace('{{user_info}}', userInfo);
 }

package/src/server/cron-scheduler.js

@@ -0,0 +1,35 @@
+import cron from 'node-cron';
+
+// Maps cron id -> active node-cron task
+const tasks = new Map();
+
+let _runCron = null;
+let _config = null;
+
+export function init(runCronFn, config) {
+  _runCron = runCronFn;
+  _config = config;
+}
+
+export function schedule(entry) {
+  // Stop existing task if rescheduling
+  if (tasks.has(entry.id)) {
+    tasks.get(entry.id).stop();
+  }
+  const task = cron.schedule(entry.schedule, () => {
+    _runCron(entry, _config).catch(e => {
+      console.error(`[cron] Error running "${entry.name}": ${e.message}`);
+    });
+  });
+  tasks.set(entry.id, task);
+  console.log(`[cron] scheduled "${entry.name}" (${entry.schedule})`);
+}
+
+export function unschedule(id) {
+  const task = tasks.get(id);
+  if (task) {
+    task.stop();
+    tasks.delete(id);
+    console.log(`[cron] unscheduled id=${id}`);
+  }
+}

package/src/server/crons.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+import { runAgentLoop, withSessionLock } from './agent.js';
+import { createClient } from './provider.js';
+import { loadSystemPrompt, resolveSystemPrompt, PATHS } from './config.js';
+import { createSession, loadSession, saveSession } from './sessions.js';
+import * as cronScheduler from './cron-scheduler.js';
+import { load as loadTelegramSessions } from '../channels/telegram/sessions.js';
+
+function loadCrons() {
+  try {
+    return JSON.parse(fs.readFileSync(PATHS.cronsFile, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+async function appendCronLog(cronId, entry) {
+  const logFile = path.join(PATHS.logsDir, `cron-${cronId}.jsonl`);
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n';
+  await fs.promises.appendFile(logFile, line, 'utf8');
+}
+
+async function writeSyntheticMessageToTelegramSession(entry, response, config) {
+  const chatId = config.telegram?.allowedUserIds?.[0];
+  if (!chatId) return;
+
+  const sessions = loadTelegramSessions();
+  const sessionId = sessions[chatId];
+  if (!sessionId) return;
+
+  const ts = new Date().toISOString().slice(0, 16).replace('T', ' ');
+  const syntheticMessage = `[Cron "${entry.name}" | ${ts}] ${response}`;
+
+  await withSessionLock(sessionId, async () => {
+    const session = await loadSession(sessionId);
+    if (!session) return;
+    session.messages.push({ role: 'assistant', content: syntheticMessage });
+    await saveSession(sessionId, session);
+  });
+}
+
+export async function runCron(entry, config) {
+  console.log(`[cron] running "${entry.name}"`);
+
+  const systemPromptTemplate = loadSystemPrompt();
+  const session = createSession(systemPromptTemplate);
+  session.messages.push({ role: 'user', content: entry.prompt });
+
+  const client = createClient(config);
+  const usageAccum = { prompt: 0, completion: 0, cacheRead: 0, cacheCreation: 0 };
+
+  function prepareMessages(messages) {
+    return messages.map((msg, i) => {
+      if (i === 0 && msg.role === 'system') {
+        return { ...msg, content: resolveSystemPrompt(msg.content, `cron-${entry.id}`) };
+      }
+      return msg;
+    });
+  }
+
+  let run;
+  try {
+    run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+  } catch (e) {
+    run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
+  }
+
+  // Log to cron JSONL
+  await appendCronLog(entry.id, {
+    cronName: entry.name,
+    status: run.status,
+    response: run.response,
+    logSummary: run.logSummary,
+  }).catch(e => console.error(`[cron] log error: ${e.message}`));
+
+  // Write synthetic message to user's Telegram session
+  await writeSyntheticMessageToTelegramSession(entry, run.response, config).catch(e => {
+    console.error(`[cron] telegram session write error: ${e.message}`);
+  });
+
+  // once: true — delete after firing
+  if (entry.once) {
+    try {
+      const crons = loadCrons().filter(c => c.id !== entry.id);
+      fs.writeFileSync(PATHS.cronsFile, JSON.stringify(crons, null, 2), 'utf8');
+      cronScheduler.unschedule(entry.id);
+    } catch (e) {
+      console.error(`[cron] cleanup error: ${e.message}`);
+    }
+  }
+}
+
+export function initCrons(config) {
+  cronScheduler.init(runCron, config);
+
+  const crons = loadCrons();
+  for (const entry of crons) {
+    try {
+      cronScheduler.schedule(entry);
+    } catch (e) {
+      console.error(`[cron] failed to schedule "${entry.name}": ${e.message}`);
+    }
+  }
+  console.log(`[cron] initialized ${crons.length} cron(s)`);
+}

package/src/server/tools.js

@@ -120,77 +120,6 @@ const SEED_TOOLS = {
     },
     code: `const filePath = path.join(process.env.HOME, '.jarvis/data/user-info.json'); const raw = await fs.promises.readFile(filePath, 'utf8').catch(() => '{"items":[]}'); const { items } = JSON.parse(raw); return { status: 'ok', items };`,
   },
-  save_tool: {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'save_tool',
-        description: 'Create or update a custom tool and make it available immediately in this session. Use this to build reusable JS tools for tasks you repeat. The tool code runs in Node.js and has access to: args, fs, path, process, require, __jarvisDir. To update an existing tool, first call get_tool to read its current code and parameters, then call save_tool with your modifications.',
-        parameters: {
-          type: 'object',
-          properties: {
-            name: {
-              type: 'string',
-              description: 'Tool name in snake_case (e.g. "parse_json_file"). Must be unique.',
-            },
-            description: {
-              type: 'string',
-              description: 'What the tool does. Be specific — the LLM uses this to decide when to call it.',
-            },
-            parameters: {
-              type: 'object',
-              description: 'JSON Schema object for the tool parameters (with type, properties, required fields).',
-            },
-            code: {
-              type: 'string',
-              description: 'The body of an async function. Must end with a return statement — the returned value becomes the tool result. Available bindings: args (your tool parameters), fs (node:fs), path (node:path), process, require, __jarvisDir (absolute path to the jarvis server directory — use path.resolve(__jarvisDir, "../..") to get the project root for npm installs). Do NOT wrap in a function declaration. Example: const raw = await fs.promises.readFile(args.filePath, "utf8"); const data = JSON.parse(raw); return { count: data.length, first: data[0] };',
-            },
-            timeout: {
-              type: 'number',
-              description: 'Optional execution timeout in milliseconds for this tool (max 600000 = 10 minutes). Use this when the tool wraps a slow operation (e.g. a network request or long computation) that exceeds the default 60-second limit. If omitted, the default 60-second timeout applies.',
-            },
-          },
-          required: ['name', 'description', 'parameters', 'code'],
-        },
-      },
-    },
-    code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); let parameters = args.parameters; if (typeof parameters === 'string') { try { parameters = JSON.parse(parameters); } catch { return { status: 'error', error: 'parameters must be a JSON Schema object, not a string. Pass the object directly, not as a JSON-serialized string.' }; } } if (typeof parameters !== 'object' || parameters === null || Array.isArray(parameters)) { return { status: 'error', error: 'parameters must be a JSON Schema object (e.g. { type: "object", properties: {...} }).' }; } const entry = { definition: { type: 'function', function: { name: args.name, description: args.description, parameters } }, code: args.code }; if (args.timeout !== undefined) { const t = Number(args.timeout); if (!Number.isFinite(t) || t <= 0) return { status: 'error', error: 'timeout must be a positive number in milliseconds.' }; entry.timeout = Math.min(t, 600_000); } tools[args.name] = entry; await fs.promises.writeFile(toolsFile, JSON.stringify(tools, null, 2), 'utf8'); return { status: 'ok', saved: args.name, timeout: entry.timeout || 60000 };`,
-  },
-  get_tool: {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'get_tool',
-        description: 'Read the full definition and code of a single tool by name. Use this before updating an existing tool so you understand its current implementation.',
-        parameters: {
-          type: 'object',
-          properties: {
-            name: {
-              type: 'string',
-              description: 'The tool name to retrieve.',
-            },
-          },
-          required: ['name'],
-        },
-      },
-    },
-    code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); const tool = tools[args.name]; if (!tool) return { status: 'not_found', name: args.name }; return { status: 'ok', name: args.name, definition: tool.definition, code: tool.code };`,
-  },
-  list_tools: {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'list_tools',
-        description: 'List all available tools with their names and descriptions. Use this to see what tools exist before creating a new one.',
-        parameters: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-    },
-    code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); const list = Object.entries(tools).map(([name, t]) => ({ name, description: t.definition.function.description })); return { status: 'ok', tools: list };`,
-  },
   npm_install: {
     definition: {
       type: 'function',
@@ -384,6 +313,198 @@ const SEED_TOOLS = {
       return { status: 'ok', path: targetPath, bytes, mode: args.mode || '644' };
     `,
   },
+  get_current_time: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'get_current_time',
+        description: 'Returns the current server time. Call this before scheduling a cron job when the user specifies a relative time (e.g. "in 2 hours", "at 3pm today") so you can calculate the correct schedule.',
+        parameters: { type: 'object', properties: {}, required: [] },
+      },
+    },
+    code: `
+      const now = new Date();
+      return {
+        status: 'ok',
+        iso: now.toISOString(),
+        local: now.toLocaleString(),
+        utcOffset: -now.getTimezoneOffset() / 60,
+      };
+    `,
+  },
+  create_cron: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'create_cron',
+        description: 'Schedule a recurring or one-time task. The prompt is executed by a fresh agent with no prior context — write it as a self-contained task. For one-time tasks (e.g. "remind me in 2 hours"), set once: true. Call get_current_time first when calculating a relative schedule.',
+        parameters: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Short identifier for this cron, e.g. "backup-nightly".' },
+            schedule: { type: 'string', description: 'Cron expression, e.g. "0 3 * * *" for 3am daily. For a one-time task, compute the exact time from get_current_time and express it as a cron expression.' },
+            prompt: { type: 'string', description: 'The task prompt the agent will receive when this cron fires. Must be self-contained. Include "use send_telegram_message to notify the user with the result" if notification is desired.' },
+            once: { type: 'boolean', description: 'If true, the cron deletes itself after firing once. Use for one-time reminders or tasks.' },
+          },
+          required: ['name', 'schedule', 'prompt'],
+        },
+      },
+    },
+    code: `
+      const { randomUUID } = require('crypto');
+      const cronsFile = path.join(process.env.HOME, '.jarvis/data/crons.json');
+      const crons = JSON.parse(await fs.promises.readFile(cronsFile, 'utf8').catch(() => '[]'));
+      const entry = {
+        id: randomUUID(),
+        name: args.name,
+        schedule: args.schedule,
+        prompt: args.prompt,
+        once: args.once || false,
+        createdAt: new Date().toISOString(),
+      };
+      crons.push(entry);
+      await fs.promises.mkdir(path.dirname(cronsFile), { recursive: true });
+      await fs.promises.writeFile(cronsFile, JSON.stringify(crons, null, 2), 'utf8');
+      return { status: 'ok', cron: entry };
+    `,
+  },
+  list_crons: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'list_crons',
+        description: 'List all scheduled cron jobs.',
+        parameters: { type: 'object', properties: {}, required: [] },
+      },
+    },
+    code: `
+      const cronsFile = path.join(process.env.HOME, '.jarvis/data/crons.json');
+      const crons = JSON.parse(await fs.promises.readFile(cronsFile, 'utf8').catch(() => '[]'));
+      return { status: 'ok', crons };
+    `,
+  },
+  delete_cron: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'delete_cron',
+        description: 'Delete a scheduled cron job by name or id.',
+        parameters: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'The cron name to delete.' },
+            id: { type: 'string', description: 'The cron id to delete.' },
+          },
+        },
+      },
+    },
+    code: `
+      const cronsFile = path.join(process.env.HOME, '.jarvis/data/crons.json');
+      const crons = JSON.parse(await fs.promises.readFile(cronsFile, 'utf8').catch(() => '[]'));
+      const idx = crons.findIndex(c => c.id === args.id || c.name === args.name);
+      if (idx === -1) return { status: 'not_found' };
+      const [removed] = crons.splice(idx, 1);
+      await fs.promises.writeFile(cronsFile, JSON.stringify(crons, null, 2), 'utf8');
+      return { status: 'ok', id: removed.id, name: removed.name };
+    `,
+  },
+  send_telegram_message: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'send_telegram_message',
+        description: 'Send a message to the Telegram user. Use this inside cron prompts to notify the user with the result of a task.',
+        parameters: {
+          type: 'object',
+          properties: {
+            message: { type: 'string', description: 'The message text to send.' },
+          },
+          required: ['message'],
+        },
+      },
+    },
+    code: `
+      const https = require('https');
+      const token = process.env.TELEGRAM_BOT_TOKEN;
+      const settingsFile = path.join(process.env.HOME, '.jarvis/data/config/settings.json');
+      const settings = JSON.parse(await fs.promises.readFile(settingsFile, 'utf8'));
+      const chatId = settings.channels?.telegram?.allowedUserIds?.[0];
+      if (!chatId) return { status: 'error', error: 'No Telegram chat_id configured.' };
+      if (!token) return { status: 'error', error: 'No TELEGRAM_BOT_TOKEN configured.' };
+      const body = JSON.stringify({ chat_id: chatId, text: args.message });
+      await new Promise((resolve, reject) => {
+        const req = https.request({
+          hostname: 'api.telegram.org',
+          path: '/bot' + token + '/sendMessage',
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        }, res => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => {
+            const parsed = JSON.parse(data);
+            if (!parsed.ok) reject(new Error(parsed.description));
+            else resolve(parsed);
+          });
+        });
+        req.on('error', reject);
+        req.write(body);
+        req.end();
+      });
+      return { status: 'ok', chatId };
+    `,
+  },
+  read_cron_log: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'read_cron_log',
+        description: 'Read the execution log for a cron job. Returns the most recent runs with status, response, and logSummary.',
+        parameters: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'The cron id.' },
+            limit: { type: 'number', description: 'Max entries to return. Defaults to 20.' },
+          },
+          required: ['id'],
+        },
+      },
+    },
+    code: `
+      const logsDir = path.join(process.env.HOME, '.jarvis/logs');
+      const logFile = path.join(logsDir, 'cron-' + args.id + '.jsonl');
+      const content = await fs.promises.readFile(logFile, 'utf8').catch(() => '');
+      const lines = content.trim().split('\\n').filter(Boolean);
+      const limit = args.limit || 20;
+      const entries = lines.slice(-limit).map(line => JSON.parse(line));
+      return { status: 'ok', entries };
+    `,
+  },
+  read_skill: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'read_skill',
+        description: 'Read the full instructions of a skill by name. Call this before executing a skill so you have the complete workflow. The skill name must match one of the available skills listed in your system prompt.',
+        parameters: {
+          type: 'object',
+          properties: {
+            name: {
+              type: 'string',
+              description: 'The skill name, e.g. "add-two-integers".',
+            },
+          },
+          required: ['name'],
+        },
+      },
+    },
+    code: `
+      const skillFile = path.join(process.env.HOME, '.jarvis/data/skills', args.name, 'skill.md');
+      const content = await fs.promises.readFile(skillFile, 'utf8').catch(() => null);
+      if (!content) return { status: 'not_found', name: args.name };
+      return { status: 'ok', name: args.name, content };
+    `,
+  },
   get_recent_sessions: {
     definition: {
       type: 'function',