@ducci/jarvis 1.0.46 → 1.0.48

package/docs/system-prompt.md

@@ -1,4 +1,4 @@
-# System Prompt (v1)
+# System Prompt (v2)
 
 This is the authoritative system prompt sent to the model at the start of every session. It is stored as the first message (`role: "system"`) in the conversation history.
 
@@ -23,14 +23,7 @@ Only the most recent messages are included in your context (sliding window). Old
 
 ## Crons
 
-You can schedule recurring or one-time tasks using cron jobs.
-
-- Use `create_cron` when the user wants to schedule something — even if they don't say "cron". Triggers: "every night", "every 2 hours", "remind me at 3pm", "notify me in 2 hours", "check X every Monday", etc.
-- Call `get_current_time` first when the user specifies a time. Note: `get_current_time` returns server time — if you know the user's timezone, convert the desired user-local time to server time before computing the cron expression.
-- The `prompt` stored in the cron is executed by a fresh agent with no prior conversation context. Write it as a complete, self-contained instruction.
-- If the user wants to be notified, include "use send_telegram_message to notify the user with the result" in the prompt. If they explicitly don't want a notification, omit it.
-- For one-time tasks, set `once: true` — the cron deletes itself after firing.
-- Use `list_crons` to show active crons, `update_cron` to modify one, `delete_cron` to remove one, `read_cron_log` to inspect past runs.
+Use `create_cron` when the user wants something scheduled — even without the word "cron". Common triggers: "every night", "every 2 hours", "remind me at 3pm", "notify me in 2 hours", "check X every Monday". See the `create_cron` and `get_current_time` tool descriptions for how to construct the schedule and prompt correctly.
 
 ## Skills
 
@@ -52,7 +45,7 @@ There are two types of responses depending on whether you need to use tools:
   "logSummary": "A concise explanation of what you did and why, written for a human reading the logs."
 }
 
-The `response` value must be a string — never an array or object. Use HTML formatting tags for readability: <b>bold</b>, <i>italic</i>, <code>inline code</code>, <pre>code blocks</pre>, <blockquote>quotes</blockquote>. Never use Markdown formatting (no **, __, `, or ```). If you need to present structured data (e.g. a list of items), format it as text within the string value.
+The `response` value must be a string — never an array or object. Use HTML formatting tags for readability — only these Telegram-supported tags are allowed: <b>bold</b>, <i>italic</i>, <u>underline</u>, <s>strikethrough</s>, <code>inline code</code>, <pre>code block</pre>, <blockquote>quote</blockquote>, <a href="URL">link</a>. For line breaks use actual newlines (\n), never <br>. Never use Markdown formatting (no **, __, `, or ```). If you need to present structured data (e.g. a list of items), format it as text within the string value.
 
 Never include markdown code fences, preamble, or any text outside this JSON object. If you cannot complete a task, explain why in the `response` field — still as valid JSON.
 
@@ -65,42 +58,11 @@ You have access to a set of tools. Each tool has a name and description that tel
 - After a tool call, verify the result before declaring the task done. Always communicate what you did and why — don't just report success, briefly explain the action taken.
 - Stop as soon as the task is complete and verified. Do not do extra work that was not asked for.
 - If a tool fails, record the error in `logSummary` and decide whether to retry with a corrected call or explain the failure to the user.
-- If the user shares personal information, persist it using the appropriate tool.
+- Proactively save user facts with `save_user_info` when the user shares personal details (name, timezone, preferences) — even if not asked.
+- Use `write_file` to create or overwrite files — never `exec` with echo/printf/heredoc (shell escaping silently corrupts content).
+- For processes that may run longer than 5 minutes: use `nohup command > /tmp/out.log 2>&1 &` and poll with `exec`.
 - Prefer using tools over making assumptions about the state of the system.
 
-## exec Safety
-
-The `exec` tool runs real shell commands on the server. Use it responsibly:
-
-- **Never scan from filesystem root.** Commands like `find /`, `find / -name ...`, or `ls -R /` will scan everything including `/proc`, `/sys`, and network mounts. They can saturate CPU and I/O for minutes. Always scope `find` to a specific directory (e.g. `find ~/jarvis -name "*.js"`).
-- **Use known paths.** Prefer `process.cwd()`, `$HOME`, or paths you already know over broad searches. Use `which <binary>` to locate executables.
-- **Prefer targeted reads.** Use `grep`, `head`, or `tail` instead of `cat` on files you haven't seen before. Large file output is truncated anyway — a targeted command gives you better signal.
-- **Avoid commands with unbounded runtime.** If a command could run indefinitely or scan an unknown-size tree, scope it first.
-
-## Writing Files
-
-Use the `write_file` tool to create or overwrite any file. Never use `exec` with `echo`, `printf`, or heredoc to write files.
-
-Shell escaping through `exec` silently corrupts file content: dollar signs become `\$`, backslashes double up, and the resulting file looks correct when printed but is broken at runtime (variables never expand, scripts fail with "command not found"). `write_file` bypasses all shell interpretation — content arrives as a JSON string and lands in the file exactly as written.
-
-- For shell scripts: pass `mode: "755"` to make the file executable in the same call.
-- For any other file: omit `mode` or use `"644"`.
-
-## Execution Timeouts
-
-Every tool call is wrapped in a server-side timeout that the tool's code cannot override:
-
-- **`exec`** — 5-minute cap. Sufficient for scans, builds, and most long-running commands.
-- **`system_install`** — 5-minute cap. Use for installing system binaries via a package manager.
-- **Custom tools via `save_tool`** — default 60s unless you pass `timeout` (in ms, max 600000). If a custom tool wraps a slow operation, set `timeout` explicitly.
-
-**For truly long-running processes (> 5 minutes)**: run in the background and poll for results:
-```sh
-nohup long-running-command > /tmp/output.log 2>&1 & echo $!
-# Check progress later
-cat /tmp/output.log
-```
-
 ## Failure Recovery
 
 When a tool or command fails:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",

package/src/channels/telegram/index.js

@@ -9,6 +9,8 @@ import { load, save } from './sessions.js';
 
 async function sendMessage(api, chatId, text, sessionId) {
   const MAX_TG = 4096;
+  // Telegram HTML mode does not support <br> — replace with newlines before sending
+  text = text.replace(/<br\s*\/?>/gi, '\n');
   const chunks = [];
   for (let i = 0; i < text.length; i += MAX_TG) {
     chunks.push(text.slice(i, i + MAX_TG));

package/src/server/agent.js

@@ -105,6 +105,72 @@ function hasConsecutiveModelErrors(messages) {
   );
 }
 
+/**
+ * Runs a subagent in its own isolated session for a single self-contained task.
+ * Called when the parent agent invokes the spawn_subagent tool.
+ */
+async function runSubagent(client, config, args, parentSessionId) {
+  const subSessionId = `sub-${crypto.randomUUID()}`;
+  const systemPromptTemplate = loadSystemPrompt();
+  const subSession = createSession(systemPromptTemplate);
+
+  let userContent = args.prompt;
+  if (args.context) {
+    userContent = `[Context: ${args.context}]\n\n${args.prompt}`;
+  }
+  subSession.messages.push({ role: 'user', content: userContent });
+
+  const subConfig = {
+    ...config,
+    excludeTools: ['spawn_subagent'],
+    maxIterations: args.maxIterations || config.maxIterations,
+    _sessionId: subSessionId,
+  };
+
+  const usageAccum = { prompt: 0, completion: 0, cacheRead: 0, cacheCreation: 0 };
+
+  function prepareMessages(messages) {
+    const resolved = messages.map((msg, i) => {
+      if (i === 0 && msg.role === 'system') {
+        return { ...msg, content: resolveSystemPrompt(msg.content, subSessionId) };
+      }
+      return msg;
+    });
+    if (resolved.length <= subConfig.contextWindow + 1) return resolved;
+    return [resolved[0], ...resolved.slice(-(subConfig.contextWindow))];
+  }
+
+  const run = await runAgentLoop(client, subConfig, subSession, prepareMessages, usageAccum);
+
+  await appendLog(subSessionId, {
+    iteration: run.iteration,
+    model: config.selectedModel,
+    userInput: args.prompt,
+    toolCalls: run.runToolCalls,
+    response: run.response,
+    logSummary: run.logSummary,
+    status: run.status,
+    parentSessionId: parentSessionId || null,
+    label: args.label || null,
+    tokenUsage: { ...usageAccum },
+  });
+
+  subSession.metadata.tokenUsage = { ...usageAccum };
+
+  try {
+    await saveSession(subSessionId, subSession);
+  } catch (e) {
+    console.error(`Failed to save subagent session ${subSessionId}:`, e);
+  }
+
+  return {
+    status: 'ok',
+    response: run.response,
+    runStatus: run.status,
+    sessionId: subSessionId,
+  };
+}
+
 /**
  * Runs a single agent loop up to maxIterations.
  * Returns { iteration, response, logSummary, status, runToolCalls, checkpoint }.
@@ -112,6 +178,9 @@ function hasConsecutiveModelErrors(messages) {
 export async function runAgentLoop(client, config, session, prepareMessages, usageAccum) {
   let tools = await loadTools();
   let toolDefs = getToolDefinitions(tools);
+  if (config.excludeTools?.length) {
+    toolDefs = toolDefs.filter(t => !config.excludeTools.includes(t.function?.name));
+  }
   let iteration = 0;
   const runToolCalls = [];
   const loopTracker = new Map();
@@ -162,7 +231,7 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
 
     const assistantMessage = modelResult.choices[0].message;
 
-    // Tool calls present — execute serially and continue loop
+    // Tool calls present — execute in parallel, then process results in order
     if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
       session.messages.push({
         role: 'assistant',
@@ -176,17 +245,42 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
         })),
       });
 
-      let stderrErrorInIteration = false;
-      for (const toolCall of assistantMessage.tool_calls) {
-        const toolName = toolCall.function.name;
-        let toolArgs;
-        let argParseError = null;
-        try {
-          toolArgs = JSON.parse(toolCall.function.arguments || '{}');
-        } catch (e) {
-          argParseError = e;
-        }
+      // Execute all tool calls concurrently; session mutations happen serially below.
+      const toolResults = await Promise.all(
+        assistantMessage.tool_calls.map(async (toolCall) => {
+          const toolName = toolCall.function.name;
+          let toolArgs;
+          let argParseError = null;
+          try {
+            toolArgs = JSON.parse(toolCall.function.arguments || '{}');
+          } catch (e) {
+            argParseError = e;
+          }
 
+          if (argParseError) {
+            return { toolCall, toolName, toolArgs: {}, argParseError, result: null, toolStatus: 'error' };
+          }
+
+          let result;
+          let toolStatus = 'ok';
+          try {
+            if (toolName === 'spawn_subagent') {
+              result = await runSubagent(client, config, toolArgs, config._sessionId);
+            } else {
+              result = await executeTool(tools, toolName, toolArgs);
+            }
+          } catch (e) {
+            result = { status: 'error', error: e.message };
+            toolStatus = 'error';
+          }
+
+          return { toolCall, toolName, toolArgs, argParseError: null, result, toolStatus };
+        })
+      );
+
+      // Process results serially to preserve message order and update trackers.
+      let stderrErrorInIteration = false;
+      for (const { toolCall, toolName, toolArgs, argParseError, result, toolStatus } of toolResults) {
         if (argParseError) {
           const errorContent = JSON.stringify({
             status: 'error',
@@ -198,15 +292,6 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
           continue;
         }
 
-        let result;
-        let toolStatus = 'ok';
-        try {
-          result = await executeTool(tools, toolName, toolArgs);
-        } catch (e) {
-          result = { status: 'error', error: e.message };
-          toolStatus = 'error';
-        }
-
         const resultObj = typeof result === 'object' && result !== null ? result : null;
         const toolFailed = toolStatus === 'error' || (resultObj && resultObj.status === 'error');
         if (toolFailed) {
@@ -620,7 +705,7 @@ async function _runHandleChat(config, sessionId, userMessage, attachments = [])
       }
 
       const runStartIndex = session.messages.length;
-      const run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+      const run = await runAgentLoop(client, { ...config, _sessionId: sessionId }, session, prepareMessages, usageAccum);
       allToolCalls.push(...run.runToolCalls);
 
       if (run.status !== 'checkpoint_reached') {

package/src/server/logging.js

@@ -11,7 +11,6 @@ export async function appendLog(sessionId, entry) {
   // Console output for better visibility
   const statusColor = entry.status === 'ok' ? chalk.green : chalk.red;
   console.log(
-    `[${chalk.dim(new Date().toLocaleTimeString())}] ` +
     `${chalk.blue('Session')}: ${chalk.dim(sessionId.slice(0, 8))} | ` +
     `${chalk.yellow('Iter')}: ${entry.iteration} | ` +
     `${chalk.cyan('Status')}: ${statusColor(entry.status)} | ` +

package/src/server/start.js

@@ -1,3 +1,11 @@
+// Prefix every console.log/error line with a date+time stamp so all output
+// (agent, cron, telegram, tools, etc.) is consistently timestamped in server.log.
+const _log = console.log.bind(console);
+const _err = console.error.bind(console);
+const ts = () => new Date().toISOString().replace('T', ' ').slice(0, 19);
+console.log = (...args) => _log(`[${ts()}]`, ...args);
+console.error = (...args) => _err(`[${ts()}]`, ...args);
+
 import { startServer } from './app.js';
 
 startServer();

package/src/server/tools.js

@@ -53,7 +53,7 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'exec',
-        description: 'Execute an arbitrary shell command on the server. Returns stdout, stderr, and exit code. Use this for any system operation: running scripts, installing packages, managing files, etc.',
+        description: 'Execute an arbitrary shell command on the server. Returns stdout, stderr, and exit code. Use this for any system operation: running scripts, managing processes, querying files, etc. Has a 5-minute timeout. Safety: never scan from filesystem root (avoid `find /`, `ls -R /`) — always scope to a specific directory. Prefer `grep`, `head`, or `tail` over `cat` on unknown files. Use `which <binary>` to locate executables. Avoid commands with unbounded runtime.',
         parameters: {
           type: 'object',
           properties: {
@@ -584,6 +584,38 @@ const SEED_TOOLS = {
       return { status: 'ok', entries };
     `,
   },
+  spawn_subagent: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'spawn_subagent',
+        description: 'Spawn an independent subagent to handle a single subtask in its own isolated context and session. Use this when processing many similar items (e.g. emails, files, URLs) where doing them serially in the same context would overflow. Each subagent runs a full agent loop with access to all tools and returns its final response. Multiple spawn_subagent calls in a single response run in parallel. The subagent has no access to the current conversation — the prompt must be fully self-contained. Do not instruct subagents to use send_telegram_message; collect their results and notify the user yourself.',
+        parameters: {
+          type: 'object',
+          properties: {
+            prompt: {
+              type: 'string',
+              description: 'The self-contained task for the subagent. Must include all necessary context — the subagent has no access to the current conversation history.',
+            },
+            context: {
+              type: 'string',
+              description: 'Optional extra context to prepend to the prompt (e.g. the item to process, such as an email body or file path).',
+            },
+            label: {
+              type: 'string',
+              description: 'Optional short label for this subagent, used in logging (e.g. "email-42", "file-scan-/tmp/foo.txt").',
+            },
+            maxIterations: {
+              type: 'number',
+              description: 'Optional cap on the number of iterations the subagent may use. Defaults to the global maxIterations setting. Use a lower value (e.g. 5) for simple subtasks in bulk processing.',
+            },
+          },
+          required: ['prompt'],
+        },
+      },
+    },
+    code: `return { status: 'error', error: 'spawn_subagent is a native tool handled by the agent runtime.' };`,
+  },
   read_skill: {
     definition: {
       type: 'function',