diff --git a/CHANGELOG.md b/CHANGELOG.md index 9a6893292e..7ae582451f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -40,10 +40,12 @@ Docs: https://docs.openclaw.ai - Slack: change default replyToMode from "off" to "all". (#14364) Thanks @nm-de. - Slack: detect control commands when channel messages start with bot mention prefixes (for example, `@Bot /new`). (#14142) Thanks @beefiker. - Signal: enforce E.164 validation for the Signal bot account prompt so mistyped numbers are caught early. (#15063) Thanks @Duartemartins. +- Discord: process DM reactions instead of silently dropping them. (#10418) Thanks @mcaxtr. - Signal: render mention placeholders as `@uuid`/`@phone` so mention gating and Clawdbot targeting work. (#2013) Thanks @alexgleason. - Onboarding/Providers: add Z.AI endpoint-specific auth choices (`zai-coding-global`, `zai-coding-cn`, `zai-global`, `zai-cn`) and expand default Z.AI model wiring. (#13456) Thanks @tomsun28. - Onboarding/Providers: update MiniMax API default/recommended models from M2.1 to M2.5, add M2.5/M2.5-Lightning model entries, and include `minimax-m2.5` in modern model filtering. (#14865) Thanks @adao-max. - Ollama: use configured `models.providers.ollama.baseUrl` for model discovery and normalize `/v1` endpoints to the native Ollama API root. (#14131) Thanks @shtse8. +- Discord: omit empty content fields for media-only messages while preserving caption whitespace. (#9507) Thanks @leszekszpunar. - Voice Call: pass Twilio stream auth token via `` instead of query string. (#14029) Thanks @mcwigglesmcgee. - Feishu: pass `Buffer` directly to the Feishu SDK upload APIs instead of `Readable.from(...)` to avoid form-data upload failures. (#10345) Thanks @youngerstyle. - Feishu: trigger mention-gated group handling only when the bot itself is mentioned (not just any mention). (#11088) Thanks @openperf. @@ -66,7 +68,9 @@ Docs: https://docs.openclaw.ai - Agents: prevent file descriptor leaks in child process cleanup. (#13565) Thanks @KyleChen26. - Agents: prevent double compaction caused by cache TTL bypassing guard. (#13514) Thanks @taw0002. - Agents: use last API call's cache tokens for context display instead of accumulated sum. (#13805) Thanks @akari-musubi. +- Agents: keep followup-runner session `totalTokens` aligned with post-compaction context by using last-call usage and shared token-accounting logic. (#14979) Thanks @shtse8. - Discord tests: use a partial @buape/carbon mock in slash command coverage. (#13262) Thanks @arosstale. +- Discord: allow channel-edit to archive/lock threads and set auto-archive duration. (#5542) Thanks @stumct. - Tests: update thread ID handling in Slack message collection tests. (#14108) Thanks @swizzmagik. ## 2026.2.9 diff --git a/src/infra/heartbeat-runner.cron-system-event-filter.test.ts b/src/infra/heartbeat-runner.cron-system-event-filter.test.ts new file mode 100644 index 0000000000..71825d1242 --- /dev/null +++ b/src/infra/heartbeat-runner.cron-system-event-filter.test.ts @@ -0,0 +1,29 @@ +import { describe, expect, it } from "vitest"; +import { isCronSystemEvent } from "./heartbeat-runner.js"; + +describe("isCronSystemEvent", () => { + it("returns false for empty entries", () => { + expect(isCronSystemEvent("")).toBe(false); + expect(isCronSystemEvent(" ")).toBe(false); + }); + + it("returns false for heartbeat ack markers", () => { + expect(isCronSystemEvent("HEARTBEAT_OK")).toBe(false); + expect(isCronSystemEvent("HEARTBEAT_OK 🦞")).toBe(false); + expect(isCronSystemEvent("heartbeat_ok")).toBe(true); + }); + + it("returns false for heartbeat poll and wake noise", () => { + expect(isCronSystemEvent("heartbeat poll: pending")).toBe(false); + expect(isCronSystemEvent("heartbeat wake complete")).toBe(false); + }); + + it("returns false for exec completion events", () => { + expect(isCronSystemEvent("Exec finished (gateway id=abc, code 0)")).toBe(false); + }); + + it("returns true for real cron reminder content", () => { + expect(isCronSystemEvent("Reminder: Check Base Scout results")).toBe(true); + expect(isCronSystemEvent("Send weekly status update to the team")).toBe(true); + }); +}); diff --git a/src/infra/heartbeat-runner.ghost-reminder.test.ts b/src/infra/heartbeat-runner.ghost-reminder.test.ts new file mode 100644 index 0000000000..54a3d0bdb2 --- /dev/null +++ b/src/infra/heartbeat-runner.ghost-reminder.test.ts @@ -0,0 +1,178 @@ +import fs from "node:fs/promises"; +import os from "node:os"; +import path from "node:path"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import type { OpenClawConfig } from "../config/config.js"; +import { telegramPlugin } from "../../extensions/telegram/src/channel.js"; +import { setTelegramRuntime } from "../../extensions/telegram/src/runtime.js"; +import * as replyModule from "../auto-reply/reply.js"; +import { resolveMainSessionKey } from "../config/sessions.js"; +import { setActivePluginRegistry } from "../plugins/runtime.js"; +import { createPluginRuntime } from "../plugins/runtime/index.js"; +import { createTestRegistry } from "../test-utils/channel-plugins.js"; +import { runHeartbeatOnce } from "./heartbeat-runner.js"; +import { enqueueSystemEvent, resetSystemEventsForTest } from "./system-events.js"; + +// Avoid pulling optional runtime deps during isolated runs. +vi.mock("jiti", () => ({ createJiti: () => () => ({}) })); + +beforeEach(() => { + const runtime = createPluginRuntime(); + setTelegramRuntime(runtime); + setActivePluginRegistry( + createTestRegistry([{ pluginId: "telegram", plugin: telegramPlugin, source: "test" }]), + ); + resetSystemEventsForTest(); +}); + +afterEach(() => { + resetSystemEventsForTest(); + vi.restoreAllMocks(); +}); + +describe("Ghost reminder bug (issue #13317)", () => { + const createConfig = async ( + tmpDir: string, + ): Promise<{ cfg: OpenClawConfig; sessionKey: string }> => { + const storePath = path.join(tmpDir, "sessions.json"); + const cfg: OpenClawConfig = { + agents: { + defaults: { + workspace: tmpDir, + heartbeat: { + every: "5m", + target: "telegram", + }, + }, + }, + channels: { telegram: { allowFrom: ["*"] } }, + session: { store: storePath }, + }; + const sessionKey = resolveMainSessionKey(cfg); + + await fs.writeFile( + storePath, + JSON.stringify( + { + [sessionKey]: { + sessionId: "sid", + updatedAt: Date.now(), + lastChannel: "telegram", + lastProvider: "telegram", + lastTo: "155462274", + }, + }, + null, + 2, + ), + ); + + return { cfg, sessionKey }; + }; + + it("does not use CRON_EVENT_PROMPT when only a HEARTBEAT_OK event is present", async () => { + const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-ghost-")); + const sendTelegram = vi.fn().mockResolvedValue({ + messageId: "m1", + chatId: "155462274", + }); + const getReplySpy = vi + .spyOn(replyModule, "getReplyFromConfig") + .mockResolvedValue({ text: "Heartbeat check-in" }); + + try { + const { cfg } = await createConfig(tmpDir); + enqueueSystemEvent("HEARTBEAT_OK", { sessionKey: resolveMainSessionKey(cfg) }); + + const result = await runHeartbeatOnce({ + cfg, + agentId: "main", + reason: "cron:test-job", + deps: { + sendTelegram, + }, + }); + + expect(result.status).toBe("ran"); + expect(getReplySpy).toHaveBeenCalledTimes(1); + const calledCtx = getReplySpy.mock.calls[0]?.[0]; + expect(calledCtx?.Provider).toBe("heartbeat"); + expect(calledCtx?.Body).not.toContain("scheduled reminder has been triggered"); + expect(calledCtx?.Body).not.toContain("relay this reminder"); + expect(sendTelegram).toHaveBeenCalled(); + } finally { + await fs.rm(tmpDir, { recursive: true, force: true }); + } + }); + + it("uses CRON_EVENT_PROMPT when an actionable cron event exists", async () => { + const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cron-")); + const sendTelegram = vi.fn().mockResolvedValue({ + messageId: "m1", + chatId: "155462274", + }); + const getReplySpy = vi + .spyOn(replyModule, "getReplyFromConfig") + .mockResolvedValue({ text: "Relay this reminder now" }); + + try { + const { cfg } = await createConfig(tmpDir); + enqueueSystemEvent("Reminder: Check Base Scout results", { + sessionKey: resolveMainSessionKey(cfg), + }); + + const result = await runHeartbeatOnce({ + cfg, + agentId: "main", + reason: "cron:reminder-job", + deps: { + sendTelegram, + }, + }); + + expect(result.status).toBe("ran"); + expect(getReplySpy).toHaveBeenCalledTimes(1); + const calledCtx = getReplySpy.mock.calls[0]?.[0]; + expect(calledCtx?.Provider).toBe("cron-event"); + expect(calledCtx?.Body).toContain("scheduled reminder has been triggered"); + expect(sendTelegram).toHaveBeenCalled(); + } finally { + await fs.rm(tmpDir, { recursive: true, force: true }); + } + }); + + it("uses CRON_EVENT_PROMPT when cron events are mixed with heartbeat noise", async () => { + const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cron-mixed-")); + const sendTelegram = vi.fn().mockResolvedValue({ + messageId: "m1", + chatId: "155462274", + }); + const getReplySpy = vi + .spyOn(replyModule, "getReplyFromConfig") + .mockResolvedValue({ text: "Relay this reminder now" }); + + try { + const { cfg, sessionKey } = await createConfig(tmpDir); + enqueueSystemEvent("HEARTBEAT_OK", { sessionKey }); + enqueueSystemEvent("Reminder: Check Base Scout results", { sessionKey }); + + const result = await runHeartbeatOnce({ + cfg, + agentId: "main", + reason: "cron:reminder-job", + deps: { + sendTelegram, + }, + }); + + expect(result.status).toBe("ran"); + expect(getReplySpy).toHaveBeenCalledTimes(1); + const calledCtx = getReplySpy.mock.calls[0]?.[0]; + expect(calledCtx?.Provider).toBe("cron-event"); + expect(calledCtx?.Body).toContain("scheduled reminder has been triggered"); + expect(sendTelegram).toHaveBeenCalled(); + } finally { + await fs.rm(tmpDir, { recursive: true, force: true }); + } + }); +}); diff --git a/src/infra/heartbeat-runner.ts b/src/infra/heartbeat-runner.ts index 1771875c04..38a5d3e752 100644 --- a/src/infra/heartbeat-runner.ts +++ b/src/infra/heartbeat-runner.ts @@ -103,6 +103,27 @@ const CRON_EVENT_PROMPT = "A scheduled reminder has been triggered. The reminder message is shown in the system messages above. " + "Please relay this reminder to the user in a helpful and friendly way."; +export function isCronSystemEvent(evt: string) { + const trimmed = evt.trim(); + if (!trimmed) { + return false; + } + + const lower = trimmed.toLowerCase(); + const heartbeatOk = HEARTBEAT_TOKEN.toLowerCase(); + if (lower === heartbeatOk || lower.startsWith(`${heartbeatOk} `)) { + return false; + } + if (lower.includes("heartbeat poll") || lower.includes("heartbeat wake")) { + return false; + } + if (lower.includes("exec finished")) { + return false; + } + + return true; +} + type HeartbeatAgentState = { agentId: string; heartbeat?: HeartbeatConfig; @@ -489,7 +510,7 @@ export async function runHeartbeatOnce(opts: { const isCronEvent = Boolean(opts.reason?.startsWith("cron:")); const pendingEvents = isExecEvent || isCronEvent ? peekSystemEvents(sessionKey) : []; const hasExecCompletion = pendingEvents.some((evt) => evt.includes("Exec finished")); - const hasCronEvents = isCronEvent && pendingEvents.length > 0; + const hasCronEvents = isCronEvent && pendingEvents.some((evt) => isCronSystemEvent(evt)); const prompt = hasExecCompletion ? EXEC_EVENT_PROMPT : hasCronEvents