alvin-bot 5.1.7 → 5.1.8

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to Alvin Bot are documented here.
 
+## [5.1.8] — 2026-05-17
+
+### Interrupted jobs auto-resume after a controlled restart
+
+If an auto-update, `/update` or `/restart` interrupted a job while it
+was running, the bot used to give up on that run and ask you to
+re-trigger it manually. Now, when the interruption was a controlled
+restart (not a crash) and it happened within the last 15 minutes, the
+job is re-run automatically on the next tick after the bot is back.
+Crash-loops are deliberately excluded — a job that keeps crashing the
+bot will never resume itself — and each interrupted run is resumed at
+most once. You can opt a single job out with `autoResume: false`.
+
+### Sub-agents report a result, not a play-by-play
+
+Finished sub-agents (background tasks, cron jobs) no longer dump a long
+step-by-step recap of how they thought and what tools they called. You
+get the compact status line (success/failed · duration · tokens) plus
+the actual result — nothing more. Cron reports still arrive in full;
+only the meta-narration is gone, since the orchestrator processes the
+real output anyway.
+
 ## [5.1.7] — 2026-05-17
 
 ### Scheduled jobs no longer run twice after a restart

package/dist/services/cron-scheduling.js

@@ -149,6 +149,15 @@ export function prepareForExecution(job, now) {
 // ── Startup catch-up ───────────────────────────────────────
 /** Default grace window for catching up an interrupted attempt on boot. */
 export const DEFAULT_CATCHUP_GRACE_MS = 6 * 60 * 60 * 1000; // 6 h
+/**
+ * Short window for *fast-resume*: when a controlled restart (auto-update,
+ * /update, /restart) interrupts a running job, re-run it immediately on
+ * the next boot instead of telling the user to re-trigger — but only if
+ * the interruption is this fresh. Deliberately minutes, not hours: a
+ * boot many hours later is the "surprise rerun" case slotAlreadyAttempted
+ * is designed to suppress; fast-resume is the immediate self-heal.
+ */
+export const DEFAULT_FAST_RESUME_MS = 15 * 60 * 1000; // 15 min
 /**
  * Returns true when the job's *current* schedule slot has already been
  * attempted — i.e. the bot fired the job for this slot before the
@@ -195,7 +204,8 @@ function slotAlreadyAttempted(job, now) {
  *
  * PURE: returns a fresh array, never mutates the input.
  */
-export function handleStartupCatchup(jobs, now, graceMs = DEFAULT_CATCHUP_GRACE_MS) {
+export function handleStartupCatchup(jobs, now, graceMs = DEFAULT_CATCHUP_GRACE_MS, opts = {}) {
+    const fastResumeMs = opts.fastResumeMs ?? DEFAULT_FAST_RESUME_MS;
     return jobs.map((job) => {
         if (!job.enabled)
             return job;
@@ -210,11 +220,29 @@ export function handleStartupCatchup(jobs, now, graceMs = DEFAULT_CATCHUP_GRACE_
             return job; // clock weirdness — skip
         if (ageMs > graceMs)
             return job; // outside grace — give up
-        // The current schedule slot has already been attempted (even if it
-        // crashed). Skip catch-up so the user doesn't get a surprise rerun
-        // hours after the originally scheduled time.
-        if (slotAlreadyAttempted(job, now))
-            return job;
+        if (slotAlreadyAttempted(job, now)) {
+            // The slot was already attempted. Normally we leave it alone so the
+            // user doesn't get a surprise rerun hours later. EXCEPTION —
+            // fast-resume: a *controlled* restart interrupted it just minutes
+            // ago. Re-run immediately instead of "please re-trigger".
+            //   • expectedRestart → never true after a crash, so a job that
+            //     crashes the bot can't loop-resume itself.
+            //   • autoResume === false → per-job opt-out.
+            //   • fresh within fastResumeMs → not the "hours later" case.
+            //   • lastFastResumeAttemptAt !== lastAttemptAt → resume a given
+            //     interrupted attempt at most once.
+            const canFastResume = opts.expectedRestart === true &&
+                job.autoResume !== false &&
+                ageMs < fastResumeMs &&
+                job.lastFastResumeAttemptAt !== job.lastAttemptAt;
+            if (!canFastResume)
+                return job;
+            return {
+                ...job,
+                nextRunAt: now,
+                lastFastResumeAttemptAt: job.lastAttemptAt,
+            };
+        }
         // Within grace, never completed, and current slot hasn't been
         // attempted yet → catch up on next tick.
         return { ...job, nextRunAt: now };

package/dist/services/cron.js

@@ -15,6 +15,7 @@ import { resolve, dirname } from "path";
 import { CRON_FILE, BOT_ROOT } from "../paths.js";
 import { prepareForExecution, handleStartupCatchup, calculateNextRunFrom, } from "./cron-scheduling.js";
 import { resolveJobByNameOrId } from "./cron-resolver.js";
+import { bootWasExpectedRestart } from "./watchdog.js";
 // ── Storage ─────────────────────────────────────────────
 function loadJobs() {
     try {
@@ -343,7 +344,9 @@ export function startScheduler() {
     // catch-up nextRunAt rewind is visible on the very next pass.
     try {
         const bootJobs = loadJobs();
-        const caught = handleStartupCatchup(bootJobs, Date.now());
+        const caught = handleStartupCatchup(bootJobs, Date.now(), undefined, {
+            expectedRestart: bootWasExpectedRestart(),
+        });
         // Only persist if something actually changed to avoid needless writes
         const mutated = caught.some((j, i) => j.nextRunAt !== bootJobs[i].nextRunAt);
         if (mutated) {

package/dist/services/subagents.js

@@ -286,7 +286,9 @@ async function runSubAgent(id, agentConfig, abort, resolvedName) {
         const effectiveCwd = inheritCwd
             ? agentConfig.workingDir || os.homedir()
             : os.homedir();
-        const systemPrompt = `You are a sub-agent named "${resolvedName}". Complete the following task autonomously and report your results clearly when done. Working directory: ${effectiveCwd}`;
+        const systemPrompt = `You are a sub-agent named "${resolvedName}". Complete the following task autonomously. Working directory: ${effectiveCwd}
+
+When done, return ONLY the final result/outcome, concisely. Do NOT narrate your intermediate steps, your reasoning, your tool calls, or a play-by-play of what you did — the orchestrator only needs the outcome (the answer, the report, the list, the artifact path), and on failure the error plus what was and wasn't done. No preamble, no "Here's what I did", no step-by-step recap. Run status, duration and token usage are reported separately, so don't restate them.`;
         // v4.12.2 — Map the toolset preset to an explicit allowedTools list.
         // The provider honors this override (see src/providers/claude-sdk-provider.ts
         // line ~140). Passing undefined = full access (provider default).

package/dist/services/watchdog.js

@@ -39,6 +39,18 @@ const BEACON_INTERVAL_MS = 30_000; // write a beacon every 30 s
 let beaconTimer = null;
 let resetTimer = null;
 let bootTime = 0;
+/** Captured in startWatchdog(): did the previous process exit via a
+ *  controlled restart? Read by the cron scheduler for fast-resume. */
+let bootExpectedRestart = false;
+/**
+ * True when this boot was preceded by a *controlled* restart
+ * (`markExpectedRestart` had set the beacon flag) rather than a crash.
+ * Returns false until startWatchdog() has run, and false after a crash —
+ * the safe default (no fast-resume) in both cases.
+ */
+export function bootWasExpectedRestart() {
+    return bootExpectedRestart;
+}
 function ensureStateDir() {
     try {
         fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -155,6 +167,11 @@ export function startWatchdog() {
     ensureStateDir();
     bootTime = Date.now();
     const previous = readBeacon();
+    // Capture whether the *previous* process exited via a controlled
+    // restart (markExpectedRestart set the flag) BEFORE writeBeacon below
+    // resets it. The cron scheduler uses this to fast-resume a job that a
+    // controlled restart interrupted, while never resuming after a crash.
+    bootExpectedRestart = previous?.expectedRestart === true;
     const decision = decideBrakeAction(previous, bootTime);
     if (decision.action === "brake") {
         console.error(`[watchdog] crash-loop brake triggered: ${decision.reason}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "5.1.7",
+  "version": "5.1.8",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",