@ducci/jarvis 1.0.51 → 1.0.53

package/package.json

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

package/src/server/agent.js

@@ -9,6 +9,12 @@ import chalk from 'chalk';
 
 const FORMAT_NUDGE = 'Your previous response was not valid JSON. Respond only with the required JSON object: {"response": "...", "logSummary": "..."}';
 const LOOP_DETECTION_THRESHOLD = 3;
+
+// Strip markdown code fences (```json...``` or ```...```) that models sometimes
+// wrap around JSON responses, which would otherwise cause JSON.parse to throw.
+function stripCodeFence(text) {
+  return text.replace(/^```(?:json)?\s*\n([\s\S]*?)\n?```\s*$/, '$1').trim();
+}
 const CONSECUTIVE_FAILURE_THRESHOLD = 3;
 const MAX_TOOL_RESULT = 4000;
 
@@ -396,20 +402,20 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
         if (nudgeContent.trim()) {
           content = nudgeContent;
         }
-        parsed = JSON.parse(nudgeContent);
+        parsed = JSON.parse(stripCodeFence(nudgeContent));
       } catch {
         // Fall through to !parsed handler; content may now carry the nudge text
       }
     } else {
       try {
-        parsed = JSON.parse(content);
+        parsed = JSON.parse(stripCodeFence(content));
       } catch {
         // Step 1: retry with fallback model
         try {
           const fallbackResult = await callModel(client, config.fallbackModel, preparedMessages, toolDefs);
           accumulateUsage(usageAccum, fallbackResult);
           const fallbackContent = fallbackResult.choices[0]?.message?.content || '';
-          parsed = JSON.parse(fallbackContent);
+          parsed = JSON.parse(stripCodeFence(fallbackContent));
           content = fallbackContent;
         } catch {
           // Step 2: nudge retry via both models
@@ -418,7 +424,7 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
             const nudgeResult = await callModelWithFallback(client, config, nudgeMessages, toolDefs);
             accumulateUsage(usageAccum, nudgeResult);
             const nudgeContent = nudgeResult.choices[0]?.message?.content || '';
-            parsed = JSON.parse(nudgeContent);
+            parsed = JSON.parse(stripCodeFence(nudgeContent));
             content = nudgeContent;
           } catch {
             // Give up
@@ -489,14 +495,14 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
 
     // Try JSON parse; if it fails, nudge retry (Layer 2)
     try {
-      parsedWrapUp = JSON.parse(wrapUpContent);
+      parsedWrapUp = JSON.parse(stripCodeFence(wrapUpContent));
     } catch {
       try {
         const nudgeMessages = [...wrapUpMessages, { role: 'user', content: FORMAT_NUDGE }];
         const nudgeResult = await callModelWithFallback(client, config, nudgeMessages, []);
         accumulateUsage(usageAccum, nudgeResult);
         const nudgeContent = nudgeResult.choices[0]?.message?.content || '';
-        parsedWrapUp = JSON.parse(nudgeContent);
+        parsedWrapUp = JSON.parse(stripCodeFence(nudgeContent));
         wrapUpContent = nudgeContent;
       } catch {
         // Layer 3: use raw text as best-effort response below

package/src/server/crons.js

@@ -60,8 +60,61 @@ export async function runCron(entry, config) {
   }
 
   let run;
+  let handoffCount = 0;
+  let previousRemaining = null;
+  const failedApproaches = [];
+  const checkpointState = {};
+
   try {
-    run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+    while (true) {
+      const runStartIndex = session.messages.length;
+
+      try {
+        run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+      } catch (e) {
+        run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
+        break;
+      }
+
+      if (run.status !== 'checkpoint_reached') break;
+
+      if (run.checkpoint.failedApproaches?.length > 0) {
+        failedApproaches.push(...run.checkpoint.failedApproaches);
+      }
+      if (run.checkpoint.state && Object.keys(run.checkpoint.state).length > 0) {
+        Object.assign(checkpointState, run.checkpoint.state);
+      }
+
+      // Zero-progress detection
+      const currentRemaining = (run.checkpoint.remaining || '').trim();
+      if (previousRemaining !== null && currentRemaining === previousRemaining) {
+        run = { ...run, status: 'intervention_required', logSummary: 'Zero progress detected in cron run.' };
+        session.messages.splice(runStartIndex, session.messages.length - runStartIndex - 1);
+        break;
+      }
+      previousRemaining = currentRemaining;
+
+      // Max handoffs
+      handoffCount++;
+      if (handoffCount > config.maxHandoffs) {
+        run = { ...run, status: 'intervention_required', logSummary: 'Max handoffs exceeded in cron run.' };
+        session.messages.splice(runStartIndex, session.messages.length - runStartIndex - 1);
+        break;
+      }
+
+      // 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.';
+      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')}]`;
+      }
+      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')}]`;
+      }
+      session.messages.push({ role: 'user', content: resumeContent });
+    }
   } catch (e) {
     run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
   }