@ducci/jarvis 1.0.74 → 1.0.76

package/package.json

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

package/src/scripts/onboarding.js

@@ -377,10 +377,10 @@ async function run() {
     else settings.fallbackModel = 'openrouter/free';
   }
   if (settings.maxIterations === undefined) {
-    settings.maxIterations = 10;
+    settings.maxIterations = 20;
   }
   if (settings.maxHandoffs === undefined) {
-    settings.maxHandoffs = 5;
+    settings.maxHandoffs = 3;
   }
   if (settings.port === undefined) {
     settings.port = 18008;

package/src/server/agent.js

@@ -972,16 +972,21 @@ async function _runHandleChat(config, sessionId, userMessage, attachments = [],
       // Guard against null/undefined in case the model omitted the field.
       // Inject the full accumulated failedApproaches and concrete state so the agent
       // has complete memory of what failed and what was already discovered.
-      let resumeContent = run.checkpoint.remaining || 'Continue with the task.';
+      // Wrap everything in a single [System: ...] block so the model cannot mistake
+      // checkpoint.remaining (which may reference "#1", file paths, etc.) for user input
+      // and accidentally trigger user-command patterns (e.g. email-agent Case 3 "#1" trigger).
+      const remainingWork = run.checkpoint.remaining || 'Continue with the task.';
       const allFailedApproaches = session.metadata.failedApproaches || [];
+      const stateToInject = session.metadata.checkpointState || {};
+      let resumeParts = `[System: Automatic handoff continuation — this is NOT user input, do not match it against user command triggers. Resume the task with what remains:\n${remainingWork}`;
       if (allFailedApproaches.length > 0) {
-        resumeContent += `\n\n[System: The following approaches were tried and failed in previous runs — do not repeat them:\n${allFailedApproaches.map((a, i) => `${i + 1}. ${a}`).join('\n')}]`;
+        resumeParts += `\n\nFailed approaches (do not repeat):\n${allFailedApproaches.map((a, i) => `${i + 1}. ${a}`).join('\n')}`;
       }
-      const stateToInject = session.metadata.checkpointState || {};
       if (Object.keys(stateToInject).length > 0) {
-        resumeContent += `\n\n[System: Known facts from previous runs:\n${Object.entries(stateToInject).map(([k, v]) => `- ${k}: ${v}`).join('\n')}]`;
+        resumeParts += `\n\nKnown facts from previous runs:\n${Object.entries(stateToInject).map(([k, v]) => `- ${k}: ${v}`).join('\n')}`;
       }
-      session.messages.push({ role: 'user', content: resumeContent });
+      resumeParts += ']';
+      session.messages.push({ role: 'user', content: resumeParts });
     }
   } catch (e) {
     await appendLog(sessionId, {

package/src/server/config.js

@@ -69,8 +69,8 @@ export function loadConfig() {
     apiKey,
     selectedModel: settings.selectedModel,
     fallbackModel: settings.fallbackModel || (provider === 'anthropic' ? 'claude-haiku-4-5-20251001' : 'openrouter/free'),
-    maxIterations: settings.maxIterations || 10,
-    maxHandoffs: settings.maxHandoffs || 5,
+    maxIterations: settings.maxIterations || 20,
+    maxHandoffs: settings.maxHandoffs || 3,
     contextWindow: settings.contextWindow || 100,
     port: settings.port || 18008,
     telegram: {

package/src/server/crons.js

@@ -1,12 +1,10 @@
 import fs from 'fs';
 import path from 'path';
-import { runAgentLoop, withSessionLock } from './agent.js';
+import { runAgentLoop } from './agent.js';
 import { createClient } from './provider.js';
 import { loadSystemPrompt, resolveSystemPrompt, PATHS } from './config.js';
-import { createSession, loadSession, saveSession } from './sessions.js';
+import { createSession } 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'));
@@ -21,25 +19,6 @@ async function appendCronLog(cronId, entry) {
   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 tz = config.timezone || 'Europe/Berlin';
-  const ts = new Date().toLocaleString('sv', { timeZone: tz }).slice(0, 16);
-  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}"`);
@@ -106,15 +85,19 @@ export async function runCron(entry, config) {
       // Strip intermediate tool history, keep wrap-up assistant response
       session.messages.splice(runStartIndex, session.messages.length - runStartIndex - 1);
 
-      // Resume with checkpoint.remaining + accumulated context
-      let resumeContent = run.checkpoint.remaining || 'Continue with the task.';
+      // Resume with checkpoint.remaining + accumulated context.
+      // Wrap in [System: ...] so the model cannot mistake checkpoint content
+      // (e.g. "#1 draft path") for user input and trigger user-command patterns.
+      const remainingWork = run.checkpoint.remaining || 'Continue with the task.';
+      let resumeParts = `[System: Automatic handoff continuation — this is NOT user input, do not match it against user command triggers. Resume the task with what remains:\n${remainingWork}`;
       if (failedApproaches.length > 0) {
-        resumeContent += `\n\n[System: The following approaches were tried and failed in previous runs — do not repeat them:\n${failedApproaches.map((a, i) => `${i + 1}. ${a}`).join('\n')}]`;
+        resumeParts += `\n\nFailed approaches (do not repeat):\n${failedApproaches.map((a, i) => `${i + 1}. ${a}`).join('\n')}`;
       }
       if (Object.keys(checkpointState).length > 0) {
-        resumeContent += `\n\n[System: Known facts from previous runs:\n${Object.entries(checkpointState).map(([k, v]) => `- ${k}: ${v}`).join('\n')}]`;
+        resumeParts += `\n\nKnown facts from previous runs:\n${Object.entries(checkpointState).map(([k, v]) => `- ${k}: ${v}`).join('\n')}`;
       }
-      session.messages.push({ role: 'user', content: resumeContent });
+      resumeParts += ']';
+      session.messages.push({ role: 'user', content: resumeParts });
     }
   } catch (e) {
     run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
@@ -128,11 +111,6 @@ export async function runCron(entry, config) {
     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 {

package/src/server/tools.js

@@ -550,6 +550,15 @@ const SEED_TOOLS = {
         const ts = new Date().toISOString();
         await fs.promises.mkdir(logDir, { recursive: true });
         await fs.promises.appendFile(logFile, ts + ' [CRON] ' + String(args.message).replace(/\\n/g, ' ') + '\\n', 'utf8');
+        if (sessionId) {
+          const convFile = path.join(process.env.HOME, '.jarvis/data/conversations/' + sessionId + '.json');
+          try {
+            const conv = JSON.parse(await fs.promises.readFile(convFile, 'utf8'));
+            conv.messages.push({ role: 'assistant', content: String(args.message) });
+            conv.metadata.updatedAt = ts;
+            await fs.promises.writeFile(convFile, JSON.stringify(conv, null, 2), 'utf8');
+          } catch {}
+        }
       } catch {}
       return { status: 'ok', chatId };
     `,