fix(heartbeat): preserve heartbeat task context

steipete · steipete · commit 0cf090bc6801 · 2026-04-29T17:39:58.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -24,6 +24,7 @@ Docs: https://docs.openclaw.ai
 
 - Exec: reject invalid per-call `host` values instead of silently falling back to the default target, so hostname-like values fail before commands run. Fixes #74426. Thanks @scr00ge-00 and @vyctorbrzezowski.
 - Google/Gemini: send non-empty placeholder content when a Gemini run is triggered with empty or filtered user content, avoiding `contents is not specified` API errors. Thanks @CaoYuhaoCarl.
+- Heartbeat: preserve non-task `HEARTBEAT.md` context around `tasks:` blocks and apply `agents.defaults.heartbeat` to all agents unless per-agent heartbeat entries restrict scope. Thanks @Sekhar03.
 - Build/Gateway: route restart, shutdown, respawn, diagnostics, command-queue cleanup, and runtime cleanup through one stable gateway lifecycle runtime entry so rebuilt packages do not strand long-running gateways on stale hashed chunks. Carries forward #73964. Thanks @pashpashpash.
 - Memory/wiki: keep broad shared-source and generated related-link blocks from turning every page into a search hit, cap noisy backlinks, support all-term searches such as people-routing queries, and prefer readable page body snippets over generated metadata. Thanks @vincentkoc.
 - Cron/Gateway: abort and bounded-clean up timed-out isolated agent turns before recording the timeout, so stale cron sessions cannot leave Discord or other chat lanes stuck in `processing` after a timeout. Thanks @vincentkoc.
diff --git a/src/auto-reply/command-auth.ts b/src/auto-reply/command-auth.ts
@@ -12,14 +12,11 @@ import {
   normalizeOptionalString,
 } from "../shared/string-coerce.js";
 import { normalizeStringEntries } from "../shared/string-normalization.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
 import {
   INTERNAL_MESSAGE_CHANNEL,
   isInternalMessageChannel,
   normalizeMessageChannel,
 } from "../utils/message-channel.js";
-
-const logger = createSubsystemLogger("auto-reply:command-auth");
 import type { MsgContext } from "./templating.js";
 
 export type CommandAuthorization = {
@@ -206,9 +203,8 @@ function resolveProviderAllowFrom(params: {
       };
     }
     if (!Array.isArray(allowFrom)) {
-      logger.warn(
-        `resolveAllowFrom returned an invalid allowFrom for provider "${providerId}", falling back to config allowFrom`,
-        { providerId, result: "invalid_result" },
+      console.warn(
+        `[command-auth] resolveAllowFrom returned an invalid allowFrom for provider "${providerId}", falling back to config allowFrom: invalid_result`,
       );
       return {
         allowFrom: resolveFallbackAllowFrom({ cfg, providerId, accountId }),
@@ -220,9 +216,8 @@ function resolveProviderAllowFrom(params: {
       hadResolutionError: false,
     };
   } catch (err) {
-    logger.warn(
-      `resolveAllowFrom threw for provider "${providerId}", falling back to config allowFrom`,
-      { providerId, error: describeAllowFromResolutionError(err) },
+    console.warn(
+      `[command-auth] resolveAllowFrom threw for provider "${providerId}", falling back to config allowFrom: ${describeAllowFromResolutionError(err)}`,
     );
     return {
       allowFrom: resolveFallbackAllowFrom({ cfg, providerId, accountId }),
diff --git a/src/config/defaults.ts b/src/config/defaults.ts
@@ -6,9 +6,6 @@ import {
   normalizeProviderConfigForConfigDefaults,
 } from "./provider-policy.js";
 import { normalizeTalkConfig } from "./talk.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-
-const logger = createSubsystemLogger("config:defaults");
 import type { ModelDefinitionConfig } from "./types.models.js";
 import type { OpenClawConfig } from "./types.openclaw.js";
 
@@ -117,7 +114,7 @@ export function applySessionDefaults(
   }
 
   const trimmed = session.mainKey.trim();
-  const warn = options.warn ?? ((message: string) => logger.warn(message));
+  const warn = options.warn ?? console.warn;
   const warnState = options.warnState ?? defaultWarnState;
 
   const next: OpenClawConfig = {
diff --git a/src/index.ts b/src/index.ts
@@ -3,9 +3,6 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { formatUncaughtError } from "./infra/errors.js";
 import { runFatalErrorHooks } from "./infra/fatal-error-hooks.js";
-import { createSubsystemLogger } from "./logging/subsystem.js";
-
-const logger = createSubsystemLogger("infra:runtime");
 import { isMainModule } from "./infra/is-main.js";
 import {
   installUnhandledRejectionHandler,
@@ -97,21 +94,24 @@ if (isMain) {
       return;
     }
     if (isBenignUncaughtExceptionError(error)) {
-      logger.warn("Non-fatal uncaught exception (continuing)", { error });
+      console.warn(
+        "[openclaw] Non-fatal uncaught exception (continuing):",
+        formatUncaughtError(error),
+      );
       return;
     }
-    logger.error("Uncaught exception", { error });
+    console.error("[openclaw] Uncaught exception:", formatUncaughtError(error));
     for (const message of runFatalErrorHooks({ reason: "uncaught_exception", error })) {
-      logger.error(message, { reason: "uncaught_exception", error });
+      console.error("[openclaw]", message);
     }
     restoreTerminalState("uncaught exception", { resumeStdinIfPaused: false });
     process.exit(1);
   });
 
   void runLegacyCliEntry(process.argv).catch((err) => {
-    logger.error("CLI failed", { error: err });
+    console.error("[openclaw] CLI failed:", formatUncaughtError(err));
     for (const message of runFatalErrorHooks({ reason: "legacy_cli_failure", error: err })) {
-      logger.error(message, { reason: "legacy_cli_failure", error: err });
+      console.error("[openclaw]", message);
     }
     restoreTerminalState("legacy cli failure", { resumeStdinIfPaused: false });
     process.exit(1);
diff --git a/src/infra/dotenv.ts b/src/infra/dotenv.ts
@@ -4,15 +4,15 @@ import path from "node:path";
 import dotenv from "dotenv";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { resolveConfigDir } from "../utils.js";
-
-const logger = createSubsystemLogger("infra:dotenv");
 import { resolveRequiredHomeDir } from "./home-dir.js";
 import {
   isDangerousHostEnvOverrideVarName,
   isDangerousHostEnvVarName,
   normalizeEnvVarKey,
 } from "./host-env-security.js";
 
+const logger = createSubsystemLogger("infra:dotenv");
+
 const BLOCKED_WORKSPACE_DOTENV_KEYS = new Set([
   "ALL_PROXY",
   "ANTHROPIC_API_KEY",
diff --git a/src/infra/heartbeat-runner.returns-default-unset.test.ts b/src/infra/heartbeat-runner.returns-default-unset.test.ts
@@ -314,14 +314,24 @@ describe("isHeartbeatEnabledForAgent", () => {
     expect(isHeartbeatEnabledForAgent(cfg, "ops")).toBe(true);
   });
 
-  it("falls back to default agent when no explicit heartbeat entries", () => {
+  it("uses global heartbeat defaults for all agents when no explicit heartbeat entries exist", () => {
     const cfg: OpenClawConfig = {
       agents: {
         defaults: { heartbeat: { every: "30m" } },
         list: [{ id: "main" }, { id: "ops" }],
       },
     };
     expect(isHeartbeatEnabledForAgent(cfg, "main")).toBe(true);
+    expect(isHeartbeatEnabledForAgent(cfg, "ops")).toBe(true);
+  });
+
+  it("falls back to default agent when no heartbeat config exists", () => {
+    const cfg: OpenClawConfig = {
+      agents: {
+        list: [{ id: "main" }, { id: "ops" }],
+      },
+    };
+    expect(isHeartbeatEnabledForAgent(cfg, "main")).toBe(true);
     expect(isHeartbeatEnabledForAgent(cfg, "ops")).toBe(false);
   });
 });
@@ -1404,6 +1414,78 @@ describe("runHeartbeatOnce", () => {
     }
   });
 
+  it("keeps non-task HEARTBEAT.md context while stripping blank-line-separated task blocks", async () => {
+    const tmpDir = await createCaseDir("openclaw-hb-tasks-context");
+    const storePath = path.join(tmpDir, "sessions.json");
+    const workspaceDir = path.join(tmpDir, "workspace");
+    await fs.mkdir(workspaceDir, { recursive: true });
+    await fs.writeFile(
+      path.join(workspaceDir, "HEARTBEAT.md"),
+      `# Keep this header
+
+Remember escalation policy.
+
+tasks:
+  - name: inbox
+    interval: 5m
+    prompt: Check urgent inbox items
+
+  - name: calendar
+    interval: 5m
+    prompt: Check calendar changes
+
+Some global directive after tasks.
+`,
+      "utf-8",
+    );
+
+    const cfg: OpenClawConfig = {
+      agents: {
+        defaults: {
+          workspace: workspaceDir,
+          heartbeat: { every: "5m", target: "whatsapp" },
+        },
+      },
+      channels: { whatsapp: { allowFrom: ["*"] } },
+      session: { store: storePath },
+    };
+    await fs.writeFile(
+      storePath,
+      JSON.stringify({
+        [resolveMainSessionKey(cfg)]: {
+          sessionId: "sid",
+          updatedAt: Date.now(),
+          lastChannel: "whatsapp",
+          lastTo: "120363401234567890@g.us",
+        },
+      }),
+    );
+    const replySpy = vi.fn().mockResolvedValue({ text: "Handled due heartbeat tasks" });
+    const sendWhatsApp = vi
+      .fn<
+        (to: string, text: string, opts?: unknown) => Promise<{ messageId: string; toJid: string }>
+      >()
+      .mockResolvedValue({ messageId: "m1", toJid: "jid" });
+
+    const res = await runHeartbeatOnce({
+      cfg,
+      deps: createHeartbeatDeps(sendWhatsApp, { getReplyFromConfig: replySpy }),
+    });
+
+    expect(res.status).toBe("ran");
+    expect(replySpy).toHaveBeenCalledTimes(1);
+    const calledCtx = replySpy.mock.calls[0]?.[0] as { Body?: string };
+    expect(calledCtx.Body).toContain("- inbox: Check urgent inbox items");
+    expect(calledCtx.Body).toContain("- calendar: Check calendar changes");
+    expect(calledCtx.Body).toContain("Additional context from HEARTBEAT.md");
+    expect(calledCtx.Body).toContain("# Keep this header");
+    expect(calledCtx.Body).toContain("Remember escalation policy.");
+    expect(calledCtx.Body).toContain("Some global directive after tasks.");
+    expect(calledCtx.Body).not.toContain("name: inbox");
+    expect(calledCtx.Body).not.toContain("name: calendar");
+    replySpy.mockReset();
+  });
+
   it("applies HEARTBEAT.md gating rules across file states and triggers", async () => {
     const cases: Array<{
       name: string;
diff --git a/src/infra/heartbeat-runner.ts b/src/infra/heartbeat-runner.ts
@@ -698,6 +698,40 @@ function appendHeartbeatWorkspacePathHint(prompt: string, workspaceDir: string):
   return `${prompt}\n${hint}`;
 }
 
+function stripHeartbeatTasksBlock(content: string): string {
+  const lines = content.split(/\r?\n/);
+  const kept: string[] = [];
+  let inTasksBlock = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!inTasksBlock && trimmed === "tasks:") {
+      inTasksBlock = true;
+      continue;
+    }
+
+    if (inTasksBlock) {
+      if (!trimmed) {
+        continue;
+      }
+      const isIndented = /^[\s]/.test(line);
+      const isTaskListItem = trimmed.startsWith("-");
+      const isTaskField =
+        trimmed.startsWith("interval:") ||
+        trimmed.startsWith("prompt:") ||
+        trimmed.startsWith("name:");
+      if (isIndented || isTaskListItem || isTaskField) {
+        continue;
+      }
+      inTasksBlock = false;
+    }
+
+    kept.push(line);
+  }
+
+  return kept.join("\n");
+}
+
 function resolveHeartbeatRunPrompt(params: {
   cfg: OpenClawConfig;
   heartbeat?: HeartbeatConfig;
@@ -742,9 +776,7 @@ ${taskList}
 After completing all due tasks, reply HEARTBEAT_OK.`;
 
       if (params.heartbeatFileContent) {
-        const directives = params.heartbeatFileContent
-          .replace(/^tasks:[\s\S]*?(?=^[^\s]|\n\n|$)/m, "")
-          .trim();
+        const directives = stripHeartbeatTasksBlock(params.heartbeatFileContent).trim();
         if (directives) {
           prompt += `\n\nAdditional context from HEARTBEAT.md:\n${directives}`;
         }
diff --git a/src/infra/temp-download.ts b/src/infra/temp-download.ts
@@ -1,8 +1,8 @@
 import crypto from "node:crypto";
 import { mkdtemp, rm } from "node:fs/promises";
 import path from "node:path";
-import { resolvePreferredOpenClawTmpDir } from "./tmp-openclaw-dir.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { resolvePreferredOpenClawTmpDir } from "./tmp-openclaw-dir.js";
 
 const logger = createSubsystemLogger("infra:temp-download");
 
diff --git a/src/infra/unhandled-rejections.ts b/src/infra/unhandled-rejections.ts
@@ -8,9 +8,6 @@ import {
   readErrorName,
 } from "./errors.js";
 import { runFatalErrorHooks } from "./fatal-error-hooks.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-
-const logger = createSubsystemLogger("infra:runtime");
 
 type UnhandledRejectionHandler = (reason: unknown) => boolean;
 type UncaughtExceptionHandler = (error: unknown) => boolean;
@@ -368,7 +365,10 @@ export function isUnhandledRejectionHandled(reason: unknown): boolean {
         return true;
       }
     } catch (err) {
-      logger.error("Unhandled rejection handler failed", { error: err });
+      console.error(
+        "[openclaw] Unhandled rejection handler failed:",
+        err instanceof Error ? (err.stack ?? err.message) : err,
+      );
     }
   }
   return false;
@@ -388,7 +388,10 @@ export function isUncaughtExceptionHandled(error: unknown): boolean {
         return true;
       }
     } catch (err) {
-      logger.error("Uncaught exception handler failed", { error: err });
+      console.error(
+        "[openclaw] Uncaught exception handler failed:",
+        err instanceof Error ? (err.stack ?? err.message) : err,
+      );
     }
   }
   return false;
@@ -397,7 +400,7 @@ export function isUncaughtExceptionHandled(error: unknown): boolean {
 export function installUnhandledRejectionHandler(): void {
   const exitWithTerminalRestore = (reason: string, error?: unknown, hookReason = reason) => {
     for (const message of runFatalErrorHooks({ reason: hookReason, error })) {
-      logger.error(message, { reason: hookReason, error });
+      console.error("[openclaw]", message);
     }
     restoreTerminalState(reason, { resumeStdinIfPaused: false });
     process.exit(1);
@@ -411,28 +414,31 @@ export function installUnhandledRejectionHandler(): void {
     // AbortError is typically an intentional cancellation (e.g., during shutdown)
     // Log it but don't crash - these are expected during graceful shutdown
     if (isAbortError(reason)) {
-      logger.warn("Suppressed AbortError", { error: reason });
+      console.warn("[openclaw] Suppressed AbortError:", formatUncaughtError(reason));
       return;
     }
 
     if (isFatalError(reason)) {
-      logger.error("FATAL unhandled rejection", { error: reason });
+      console.error("[openclaw] FATAL unhandled rejection:", formatUncaughtError(reason));
       exitWithTerminalRestore("fatal unhandled rejection", reason, "fatal_unhandled_rejection");
       return;
     }
 
     if (isConfigError(reason)) {
-      logger.error("CONFIGURATION ERROR - requires fix", { error: reason });
+      console.error("[openclaw] CONFIGURATION ERROR - requires fix:", formatUncaughtError(reason));
       exitWithTerminalRestore("configuration error", reason, "configuration_error");
       return;
     }
 
     if (isTransientUnhandledRejectionError(reason)) {
-      logger.warn("Non-fatal unhandled rejection (continuing)", { error: reason });
+      console.warn(
+        "[openclaw] Non-fatal unhandled rejection (continuing):",
+        formatUncaughtError(reason),
+      );
       return;
     }
 
-    logger.error("Unhandled promise rejection", { error: reason });
+    console.error("[openclaw] Unhandled promise rejection:", formatUncaughtError(reason));
     exitWithTerminalRestore("unhandled rejection", reason, "unhandled_rejection");
   });
 }
diff --git a/src/security/windows-acl.ts b/src/security/windows-acl.ts
@@ -1,7 +1,7 @@
 import os from "node:os";
 import path from "node:path";
-import { runExec } from "../process/exec.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { runExec } from "../process/exec.js";
 import { normalizeLowercaseStringOrEmpty } from "../shared/string-coerce.js";
 
 const log = createSubsystemLogger("security/windows-acl");
