openclaw-threema 0.7.1 → 0.7.4

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 0.7.4 (2026-07-05)
+
+### Fixed
+
+- **Outbound image/file media in normal agent replies now works** (the standard
+  `MEDIA:` directive). Previously the reply `deliver` handlers only had branches
+  for audio-as-voice and text — any image/file attachment fell through into the
+  text path and was silently dropped (no blob upload, no error). The agent could
+  send a picture and the user would receive only the caption text, if anything.
+- Both `deliver` handlers (E2E + fallback pipeline) now resolve outbound media the
+  way core supplies it: prefer `payload.mediaUrls` (array) and fall back to the
+  legacy `payload.mediaUrl` (string), matching core's `resolveOutboundMediaUrls`.
+  Non-audio media is sent via the existing `outbound.sendMedia` pipeline (which
+  already handles local-path/`MEDIA_ALLOWED_BASE` validation + blob upload), with
+  the reply text ridden along as the caption. If every media send fails, it falls
+  back to sending the text so the reply is never lost.
+- Note: outbound media must still live under `~/.openclaw/media/` (exfiltration
+  guard, `MEDIA_ALLOWED_BASE`). Paths outside are rejected by design.
+
+## 0.7.3 (2026-06-26)
+
+### Changed
+
+- **Memory-briefing now uses "Variante C" (decided by aza 2026-06-21).** Previously
+  the full memory snapshot (Current State + entire Akut section) was appended to
+  *every* inbound Threema message — which read like an unsolicited status card and
+  burned tokens. New behavior:
+  - **Short briefing on every inbound:** just 1-2 core lines — live `openclaw --version`
+    plus the single most-acute pending one-liner.
+  - **Full snapshot only after an idle gap (> 2 h)** per session, so the agent
+    re-orients after longer pauses without spamming the full block each turn.
+  - **OpenClaw version is pulled LIVE** via `openclaw --version` (10-min cache),
+    instead of a static line copied from MEMORY.md — fixes the "briefing shows a
+    stale/wrong version" annoyance.
+  - Per-session idle tracking (`lastInboundBySession`), short/full briefings cached
+    60 s per workspace, version cached 10 min. Fail-silent throughout; CommandBody /
+    RawBody stay clean for slash-command parsing.
+
+## 0.7.2 (2026-06-17)
+
+### Fixed
+
+- Added `actions` adapter (`describeMessageTool` / `supportsAction` / `handleAction`)
+  so the shared `message` tool's `action=send` works on Threema. Previously core
+  threw `Channel threema does not support action send`, which also broke internal
+  flows such as the post-restart "interrupted main session recovery" notice.
+  Text + media sends reuse the existing `ThreemaClient` / `outbound.sendMedia`
+  pipeline (incl. SSRF/local-path validation). Accepts `to`/`target`/`chatId`
+  and `message`/`text`/`caption` plus `media`/`mediaUrl`/`filePath`/`path` aliases.
+- Corrected stale `export const version` (was `0.6.7`) to track package version.
+
 ## 0.7.1 (2026-05-09)
 
 ### Fixed

package/dist/index.js

@@ -22,6 +22,74 @@ const MEDIA_INBOUND_DIR = path.join(process.env.HOME || "/tmp", ".openclaw", "me
 const briefingCache = new Map();
 const BRIEFING_CACHE_TTL_MS = 60_000;
 const BRIEFING_MAX_BYTES = 8192;
+// --- Variante C state (decided by aza 2026-06-21) ---
+// Short briefing on every inbound (1-2 core lines: live OC version + most acute
+// pending line). Full block ONLY once after a session gap > threshold.
+const BRIEFING_FULL_GAP_MS = 2 * 60 * 60 * 1000; // 2 h
+const lastInboundBySession = new Map();
+// Live OpenClaw version, cached for a while (cheap spawn, but avoid per-msg cost).
+let ocVersionCache = { value: "", expiresAt: 0 };
+const OC_VERSION_TTL_MS = 10 * 60 * 1000; // 10 min
+function getLiveOpenClawVersion() {
+    const now = Date.now();
+    if (ocVersionCache.value && ocVersionCache.expiresAt > now)
+        return ocVersionCache.value;
+    let version = "";
+    try {
+        const res = spawnSync("openclaw", ["--version"], { timeout: 4000, encoding: "utf8" });
+        if (res.status === 0 && typeof res.stdout === "string") {
+            // Output may be like "openclaw 2026.6.9" or just "2026.6.9"
+            const m = res.stdout.match(/\d{4}\.\d+\.\d+/);
+            version = m ? m[0] : res.stdout.trim().split(/\s+/).pop() || "";
+        }
+    }
+    catch {
+        /* fail-silent */
+    }
+    ocVersionCache = { value: version, expiresAt: now + OC_VERSION_TTL_MS };
+    return version;
+}
+// Extract the single most-acute pending item as a short one-liner.
+// The "Akut" section is organized as "### <Topic>" subsections; the first
+// non-done (### that is not ~~struck~~ / not marked ERLEDIGT) topic title is
+// the most useful single line. Falls back to the first content bullet.
+function extractTopPendingLine(acutePending) {
+    if (!acutePending)
+        return "";
+    const lines = acutePending.split(/\r?\n/);
+    let firstContent = "";
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!trimmed)
+            continue;
+        if (/^##\s/.test(trimmed))
+            continue; // the "## Akut" header itself
+        if (/^_/.test(trimmed))
+            continue; // italic meta lines
+        // Prefer a "### Topic" subsection title that is not done/struck-through.
+        if (/^#{3,6}\s/.test(trimmed)) {
+            const title = trimmed.replace(/^#{3,6}\s+/, "").trim();
+            const isDone = /~~|ERLEDIGT|ABGESCHLOSSEN|\u2705/i.test(title);
+            if (!isDone) {
+                let clean = title.replace(/~~/g, "").replace(/\*\*/g, "").trim();
+                if (clean.length > 160)
+                    clean = clean.slice(0, 157) + "...";
+                if (clean)
+                    return clean;
+            }
+            continue;
+        }
+        if (/^[-*]\s*$/.test(trimmed))
+            continue; // empty bullets
+        if (!firstContent) {
+            let clean = trimmed.replace(/^[-*]\s+/, "").replace(/~~/g, "").replace(/\*\*/g, "").trim();
+            if (clean.length > 160)
+                clean = clean.slice(0, 157) + "...";
+            firstContent = clean;
+        }
+    }
+    return firstContent;
+}
 function readBoundedFile(filePath) {
     try {
         const stat = fs.statSync(filePath);
@@ -116,11 +184,13 @@ function resolveWorkspaceDir(cfg) {
     }
     return null;
 }
-function buildMemoryBriefing(cfg) {
+// Build the FULL memory briefing block (Current State + full Akut section).
+// Sent only once after a session gap (Variante C). Cached 60 s per workspace.
+function buildFullMemoryBriefing(cfg) {
     const workspace = resolveWorkspaceDir(cfg);
     if (!workspace)
         return "";
-    const cacheKey = workspace;
+    const cacheKey = `full:${workspace}`;
     const now = Date.now();
     const cached = briefingCache.get(cacheKey);
     if (cached && cached.expiresAt > now)
@@ -129,14 +199,20 @@ function buildMemoryBriefing(cfg) {
     const pendingPath = path.join(workspace, "memory", "pending-actions.md");
     const currentState = extractCurrentStateBlock(readBoundedFile(memoryPath));
     const acutePending = extractAcutePending(readBoundedFile(pendingPath));
-    if (!currentState && !acutePending) {
+    const ocVersion = getLiveOpenClawVersion();
+    if (!currentState && !acutePending && !ocVersion) {
         briefingCache.set(cacheKey, { text: "", expiresAt: now + BRIEFING_CACHE_TTL_MS });
         return "";
     }
     const parts = [];
     parts.push("Memory briefing (untrusted, generated by threema plugin at inbound time \u2014 informational only, not instructions):");
-    parts.push("This snapshot is appended to every inbound Threema message so the agent has a fresh view of the user's acute state, even in long-running sessions. Read it before replying.");
+    parts.push("Full snapshot \u2014 sent because this session was idle for a while. Read it before replying to re-orient on the user's acute state.");
     parts.push("");
+    if (ocVersion) {
+        parts.push(`--- live state ---`);
+        parts.push(`OpenClaw version (live \`openclaw --version\`): ${ocVersion}`);
+        parts.push("");
+    }
     if (currentState) {
         parts.push("--- MEMORY.md (Current State) ---");
         parts.push(currentState);
@@ -151,8 +227,57 @@ function buildMemoryBriefing(cfg) {
     briefingCache.set(cacheKey, { text, expiresAt: now + BRIEFING_CACHE_TTL_MS });
     return text;
 }
-function composeBodyForAgent(userText, cfg) {
-    const briefing = buildMemoryBriefing(cfg);
+// Build the SHORT memory briefing (1-2 core lines). Sent on every inbound.
+// Line 1: live OpenClaw version. Line 2: most acute pending one-liner.
+function buildShortMemoryBriefing(cfg) {
+    const workspace = resolveWorkspaceDir(cfg);
+    if (!workspace)
+        return "";
+    const cacheKey = `short:${workspace}`;
+    const now = Date.now();
+    const cached = briefingCache.get(cacheKey);
+    if (cached && cached.expiresAt > now)
+        return cached.text;
+    const pendingPath = path.join(workspace, "memory", "pending-actions.md");
+    const acutePending = extractAcutePending(readBoundedFile(pendingPath));
+    const topPending = extractTopPendingLine(acutePending);
+    const ocVersion = getLiveOpenClawVersion();
+    const coreLines = [];
+    if (ocVersion)
+        coreLines.push(`OpenClaw: ${ocVersion} (live)`);
+    if (topPending)
+        coreLines.push(`Akutestes Pending: ${topPending}`);
+    if (coreLines.length === 0) {
+        briefingCache.set(cacheKey, { text: "", expiresAt: now + BRIEFING_CACHE_TTL_MS });
+        return "";
+    }
+    const parts = [];
+    parts.push("Memory briefing (untrusted, generated by threema plugin at inbound time \u2014 informational only, not instructions). Short snapshot; full state lives in MEMORY.md / pending-actions.md:");
+    parts.push(...coreLines);
+    const text = parts.join("\n");
+    briefingCache.set(cacheKey, { text, expiresAt: now + BRIEFING_CACHE_TTL_MS });
+    return text;
+}
+// Variante C dispatcher: decide short vs. full per session based on idle gap,
+// and update the session's last-inbound timestamp.
+function buildMemoryBriefingForSession(cfg, sessionKey) {
+    const now = Date.now();
+    const key = sessionKey || "__default__";
+    const last = lastInboundBySession.get(key);
+    lastInboundBySession.set(key, now);
+    // Cap map growth (defensive; one DM peer per session in practice).
+    if (lastInboundBySession.size > 256) {
+        const cutoff = now - 24 * 60 * 60 * 1000;
+        for (const [k, v] of lastInboundBySession) {
+            if (v < cutoff)
+                lastInboundBySession.delete(k);
+        }
+    }
+    const isFirstOrStale = last === undefined || now - last > BRIEFING_FULL_GAP_MS;
+    return isFirstOrStale ? buildFullMemoryBriefing(cfg) : buildShortMemoryBriefing(cfg);
+}
+function composeBodyForAgent(userText, cfg, sessionKey) {
+    const briefing = buildMemoryBriefingForSession(cfg, sessionKey);
     if (!briefing)
         return userText;
     return `${userText}\n\n[memory_briefing]\n${briefing}\n[/memory_briefing]`;
@@ -1513,6 +1638,124 @@ const threemaChannel = {
             });
         },
     },
+    // ============================================================================
+    // Message-Tool Action Adapter — powers the shared `message` tool
+    // (action=send) and internal flows like restart-recovery notices.
+    // Without this, core throws "Channel threema does not support action send".
+    // Normal agent replies go through `outbound.sendText`; this is the
+    // explicit/proactive send surface.
+    // ============================================================================
+    actions: {
+        describeMessageTool: (_params) => {
+            return {
+                actions: ["send"],
+                capabilities: [],
+            };
+        },
+        supportsAction: ({ action }) => action === "send",
+        handleAction: async (ctx) => {
+            const { action, params, cfg } = ctx;
+            if (action !== "send") {
+                return {
+                    isError: true,
+                    content: [
+                        { type: "text", text: `Threema: unsupported action "${action}".` },
+                    ],
+                };
+            }
+            const threemaCfg = getThreemaConfig(cfg);
+            if (!threemaCfg?.gatewayId || !threemaCfg?.secretKey) {
+                return {
+                    isError: true,
+                    content: [
+                        { type: "text", text: "Threema not configured: missing gatewayId or secretKey." },
+                    ],
+                };
+            }
+            // Resolve destination from common param aliases.
+            const rawTo = (typeof params?.to === "string" && params.to) ||
+                (typeof params?.target === "string" && params.target) ||
+                (typeof params?.chatId === "string" && params.chatId) ||
+                "";
+            if (!rawTo) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "Threema send: missing 'to'/'target'." }],
+                };
+            }
+            const to = normalizeThreemaTarget(rawTo);
+            if (!isValidThreemaId(to)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Threema send: invalid Threema ID "${rawTo}".` }],
+                };
+            }
+            const mediaUrl = (typeof params?.media === "string" && params.media) ||
+                (typeof params?.mediaUrl === "string" && params.mediaUrl) ||
+                (typeof params?.filePath === "string" && params.filePath) ||
+                (typeof params?.path === "string" && params.path) ||
+                "";
+            const text = (typeof params?.message === "string" && params.message) ||
+                (typeof params?.text === "string" && params.text) ||
+                (typeof params?.caption === "string" && params.caption) ||
+                "";
+            if (!text && !mediaUrl) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "Threema send: nothing to send (no message or media)." }],
+                };
+            }
+            try {
+                const client = new ThreemaClient(threemaCfg);
+                // Media path: delegate to the same outbound.sendMedia pipeline so all
+                // SSRF/local-path validation stays in one place.
+                if (mediaUrl) {
+                    const result = await threemaChannel.outbound.sendMedia({
+                        cfg,
+                        to,
+                        text,
+                        mediaUrl,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Threema media sent to ${to} (messageId ${result?.messageId ?? "?"}).`,
+                            },
+                        ],
+                        meta: result,
+                    };
+                }
+                // Text path.
+                const formatted = markdownToThreema(text);
+                const messageId = client.isE2EEnabled
+                    ? await client.sendE2E(to, formatted)
+                    : await client.sendSimple(to, formatted);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Threema message sent to ${to} (messageId ${messageId.trim()}).`,
+                        },
+                    ],
+                    meta: {
+                        channel: "threema",
+                        messageId: messageId.trim(),
+                        chatId: to,
+                        timestamp: Date.now(),
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [
+                        { type: "text", text: `Threema send failed: ${err?.message ?? String(err)}` },
+                    ],
+                };
+            }
+        },
+    },
 };
 const COALESCE_WINDOW_MS = 3000; // 3 second coalescing window
 const COALESCE_MAX_PARTS = 5; // Max parts before flushing
@@ -1645,7 +1888,7 @@ async function queueInboundForCoalescing(sender, part, dispatcher) {
 }
 export const id = "threema";
 export const name = "Threema Gateway";
-export const version = "0.6.7";
+export const version = "0.7.4";
 export const description = "Threema messaging channel via Threema Gateway API (E2E encrypted, with media support)";
 export default function register(api) {
     try {
@@ -1791,7 +2034,11 @@ export default function register(api) {
                             const channelRuntime = runtime?.channel;
                             if (channelRuntime?.routing?.resolveAgentRoute && channelRuntime?.reply?.finalizeInboundContext && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                                 try {
-                                    const currentCfg = runtime.config.loadConfig();
+                                    // Use the read-only runtime config snapshot. loadConfig() is
+                                    // deprecated (deprecated-internal-config-api guard) and slated
+                                    // for removal; current() returns a DeepReadonly<OpenClawConfig>
+                                    // which we only read here (route resolution + memory briefing).
+                                    const currentCfg = runtime.config.current();
                                     // 1. Resolve the agent route and session key
                                     const route = channelRuntime.routing.resolveAgentRoute({
                                         cfg: currentCfg,
@@ -1813,7 +2060,7 @@ export default function register(api) {
                                     //    sees the current acute state on every inbound, regardless
                                     //    of how long the session has been running. CommandBody and
                                     //    RawBody stay clean for slash-command parsing.
-                                    const bodyForAgent = composeBodyForAgent(merged.mergedText, currentCfg);
+                                    const bodyForAgent = composeBodyForAgent(merged.mergedText, currentCfg, sessionKey);
                                     const msgCtx = channelRuntime.reply.finalizeInboundContext({
                                         Body: merged.mergedText,
                                         RawBody: merged.mergedText,
@@ -1888,6 +2135,42 @@ export default function register(api) {
                                                     }
                                                 }
                                                 else {
+                                                    // Media path (non-audio): if the reply carries image/file media,
+                                                    // send it as a Threema file message. Core provides media as
+                                                    // `mediaUrls` (array, preferred) or legacy `mediaUrl` (string).
+                                                    const mediaUrls = Array.isArray(payload.mediaUrls) && payload.mediaUrls.length > 0
+                                                        ? payload.mediaUrls.filter((u) => typeof u === "string" && u.length > 0)
+                                                        : (typeof payload.mediaUrl === "string" && payload.mediaUrl
+                                                            ? [payload.mediaUrl]
+                                                            : []);
+                                                    if (mediaUrls.length > 0 && replyClient.isE2EEnabled) {
+                                                        const caption = markdownToThreema(payload.text ?? payload.body) || undefined;
+                                                        let sentAny = false;
+                                                        for (let i = 0; i < mediaUrls.length; i++) {
+                                                            const mu = mediaUrls[i];
+                                                            try {
+                                                                await threemaChannel.outbound.sendMedia({
+                                                                    cfg: currentCfg,
+                                                                    to: from,
+                                                                    text: i === 0 ? (caption ?? "") : "",
+                                                                    mediaUrl: mu,
+                                                                });
+                                                                sentAny = true;
+                                                            }
+                                                            catch (mediaErr) {
+                                                                api.logger?.error?.(`Threema: media send failed for ${mu}: ${mediaErr?.message}`);
+                                                            }
+                                                        }
+                                                        // If at least one media went out, we're done (caption rode along).
+                                                        // If ALL media failed, fall through to text so the reply isn't lost.
+                                                        if (sentAny)
+                                                            return;
+                                                        const fallbackText = markdownToThreema(payload.text ?? payload.body);
+                                                        if (fallbackText) {
+                                                            await replyClient.sendE2E(from, fallbackText);
+                                                        }
+                                                        return;
+                                                    }
                                                     // Send as text (existing logic)
                                                     const text = markdownToThreema(payload.text ?? payload.body);
                                                     if (!text)
@@ -2017,7 +2300,9 @@ export default function register(api) {
                                 && channelRuntime?.reply?.finalizeInboundContext
                                 && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                                 try {
-                                    const currentCfg = runtime.config.loadConfig();
+                                    // Read-only runtime config snapshot (see text path above):
+                                    // loadConfig() is deprecated and on the removal list.
+                                    const currentCfg = runtime.config.current();
                                     // Resolve the same agent route + session key the text path uses
                                     // so file inbounds end up in the live Threema DM session.
                                     const route = channelRuntime.routing.resolveAgentRoute({
@@ -2034,7 +2319,7 @@ export default function register(api) {
                                         dmScope: "per-account-channel-peer",
                                     });
                                     const senderAllowed = allowFrom.length === 0 || allowFrom.includes(from);
-                                    const bodyForAgent = composeBodyForAgent(fileBody, currentCfg);
+                                    const bodyForAgent = composeBodyForAgent(fileBody, currentCfg, sessionKey);
                                     const fileCtx = channelRuntime.reply.finalizeInboundContext({
                                         Body: fileBody,
                                         RawBody: fileBody,
@@ -2112,6 +2397,42 @@ export default function register(api) {
                                                     }
                                                 }
                                                 else {
+                                                    // Media path (non-audio): if the reply carries image/file media,
+                                                    // send it as a Threema file message. Core provides media as
+                                                    // `mediaUrls` (array, preferred) or legacy `mediaUrl` (string).
+                                                    const mediaUrls = Array.isArray(payload.mediaUrls) && payload.mediaUrls.length > 0
+                                                        ? payload.mediaUrls.filter((u) => typeof u === "string" && u.length > 0)
+                                                        : (typeof payload.mediaUrl === "string" && payload.mediaUrl
+                                                            ? [payload.mediaUrl]
+                                                            : []);
+                                                    if (mediaUrls.length > 0 && replyClient.isE2EEnabled) {
+                                                        const caption = markdownToThreema(payload.text ?? payload.body) || undefined;
+                                                        let sentAny = false;
+                                                        for (let i = 0; i < mediaUrls.length; i++) {
+                                                            const mu = mediaUrls[i];
+                                                            try {
+                                                                await threemaChannel.outbound.sendMedia({
+                                                                    cfg: currentCfg,
+                                                                    to: from,
+                                                                    text: i === 0 ? (caption ?? "") : "",
+                                                                    mediaUrl: mu,
+                                                                });
+                                                                sentAny = true;
+                                                            }
+                                                            catch (mediaErr) {
+                                                                api.logger?.error?.(`Threema: media send failed for ${mu}: ${mediaErr?.message}`);
+                                                            }
+                                                        }
+                                                        // If at least one media went out, we're done (caption rode along).
+                                                        // If ALL media failed, fall through to text so the reply isn't lost.
+                                                        if (sentAny)
+                                                            return;
+                                                        const fallbackText = markdownToThreema(payload.text ?? payload.body);
+                                                        if (fallbackText) {
+                                                            await replyClient.sendE2E(from, fallbackText);
+                                                        }
+                                                        return;
+                                                    }
                                                     // Send as text (existing logic)
                                                     const text = markdownToThreema(payload.text ?? payload.body);
                                                     if (!text)

package/index.ts

@@ -174,6 +174,67 @@ const briefingCache: Map<string, BriefingCacheEntry> = new Map();
 const BRIEFING_CACHE_TTL_MS = 60_000;
 const BRIEFING_MAX_BYTES = 8192;
 
+// --- Variante C state (decided by aza 2026-06-21) ---
+// Short briefing on every inbound (1-2 core lines: live OC version + most acute
+// pending line). Full block ONLY once after a session gap > threshold.
+const BRIEFING_FULL_GAP_MS = 2 * 60 * 60 * 1000; // 2 h
+const lastInboundBySession: Map<string, number> = new Map();
+// Live OpenClaw version, cached for a while (cheap spawn, but avoid per-msg cost).
+let ocVersionCache: { value: string; expiresAt: number } = { value: "", expiresAt: 0 };
+const OC_VERSION_TTL_MS = 10 * 60 * 1000; // 10 min
+
+function getLiveOpenClawVersion(): string {
+  const now = Date.now();
+  if (ocVersionCache.value && ocVersionCache.expiresAt > now) return ocVersionCache.value;
+  let version = "";
+  try {
+    const res = spawnSync("openclaw", ["--version"], { timeout: 4000, encoding: "utf8" });
+    if (res.status === 0 && typeof res.stdout === "string") {
+      // Output may be like "openclaw 2026.6.9" or just "2026.6.9"
+      const m = res.stdout.match(/\d{4}\.\d+\.\d+/);
+      version = m ? m[0] : res.stdout.trim().split(/\s+/).pop() || "";
+    }
+  } catch {
+    /* fail-silent */
+  }
+  ocVersionCache = { value: version, expiresAt: now + OC_VERSION_TTL_MS };
+  return version;
+}
+
+// Extract the single most-acute pending item as a short one-liner.
+// The "Akut" section is organized as "### <Topic>" subsections; the first
+// non-done (### that is not ~~struck~~ / not marked ERLEDIGT) topic title is
+// the most useful single line. Falls back to the first content bullet.
+function extractTopPendingLine(acutePending: string): string {
+  if (!acutePending) return "";
+  const lines = acutePending.split(/\r?\n/);
+  let firstContent = "";
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    if (/^##\s/.test(trimmed)) continue; // the "## Akut" header itself
+    if (/^_/.test(trimmed)) continue; // italic meta lines
+    // Prefer a "### Topic" subsection title that is not done/struck-through.
+    if (/^#{3,6}\s/.test(trimmed)) {
+      const title = trimmed.replace(/^#{3,6}\s+/, "").trim();
+      const isDone = /~~|ERLEDIGT|ABGESCHLOSSEN|\u2705/i.test(title);
+      if (!isDone) {
+        let clean = title.replace(/~~/g, "").replace(/\*\*/g, "").trim();
+        if (clean.length > 160) clean = clean.slice(0, 157) + "...";
+        if (clean) return clean;
+      }
+      continue;
+    }
+    if (/^[-*]\s*$/.test(trimmed)) continue; // empty bullets
+    if (!firstContent) {
+      let clean = trimmed.replace(/^[-*]\s+/, "").replace(/~~/g, "").replace(/\*\*/g, "").trim();
+      if (clean.length > 160) clean = clean.slice(0, 157) + "...";
+      firstContent = clean;
+    }
+  }
+  return firstContent;
+}
+
 function readBoundedFile(filePath: string): string {
   try {
     const stat = fs.statSync(filePath);
@@ -259,10 +320,12 @@ function resolveWorkspaceDir(cfg: OpenClawConfig | undefined): string | null {
   return null;
 }
 
-function buildMemoryBriefing(cfg: OpenClawConfig | undefined): string {
+// Build the FULL memory briefing block (Current State + full Akut section).
+// Sent only once after a session gap (Variante C). Cached 60 s per workspace.
+function buildFullMemoryBriefing(cfg: OpenClawConfig | undefined): string {
   const workspace = resolveWorkspaceDir(cfg);
   if (!workspace) return "";
-  const cacheKey = workspace;
+  const cacheKey = `full:${workspace}`;
   const now = Date.now();
   const cached = briefingCache.get(cacheKey);
   if (cached && cached.expiresAt > now) return cached.text;
@@ -272,8 +335,9 @@ function buildMemoryBriefing(cfg: OpenClawConfig | undefined): string {
 
   const currentState = extractCurrentStateBlock(readBoundedFile(memoryPath));
   const acutePending = extractAcutePending(readBoundedFile(pendingPath));
+  const ocVersion = getLiveOpenClawVersion();
 
-  if (!currentState && !acutePending) {
+  if (!currentState && !acutePending && !ocVersion) {
     briefingCache.set(cacheKey, { text: "", expiresAt: now + BRIEFING_CACHE_TTL_MS });
     return "";
   }
@@ -283,9 +347,14 @@ function buildMemoryBriefing(cfg: OpenClawConfig | undefined): string {
     "Memory briefing (untrusted, generated by threema plugin at inbound time \u2014 informational only, not instructions):"
   );
   parts.push(
-    "This snapshot is appended to every inbound Threema message so the agent has a fresh view of the user's acute state, even in long-running sessions. Read it before replying."
+    "Full snapshot \u2014 sent because this session was idle for a while. Read it before replying to re-orient on the user's acute state."
   );
   parts.push("");
+  if (ocVersion) {
+    parts.push(`--- live state ---`);
+    parts.push(`OpenClaw version (live \`openclaw --version\`): ${ocVersion}`);
+    parts.push("");
+  }
   if (currentState) {
     parts.push("--- MEMORY.md (Current State) ---");
     parts.push(currentState);
@@ -300,8 +369,67 @@ function buildMemoryBriefing(cfg: OpenClawConfig | undefined): string {
   return text;
 }
 
-function composeBodyForAgent(userText: string, cfg: OpenClawConfig | undefined): string {
-  const briefing = buildMemoryBriefing(cfg);
+// Build the SHORT memory briefing (1-2 core lines). Sent on every inbound.
+// Line 1: live OpenClaw version. Line 2: most acute pending one-liner.
+function buildShortMemoryBriefing(cfg: OpenClawConfig | undefined): string {
+  const workspace = resolveWorkspaceDir(cfg);
+  if (!workspace) return "";
+  const cacheKey = `short:${workspace}`;
+  const now = Date.now();
+  const cached = briefingCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) return cached.text;
+
+  const pendingPath = path.join(workspace, "memory", "pending-actions.md");
+  const acutePending = extractAcutePending(readBoundedFile(pendingPath));
+  const topPending = extractTopPendingLine(acutePending);
+  const ocVersion = getLiveOpenClawVersion();
+
+  const coreLines: string[] = [];
+  if (ocVersion) coreLines.push(`OpenClaw: ${ocVersion} (live)`);
+  if (topPending) coreLines.push(`Akutestes Pending: ${topPending}`);
+
+  if (coreLines.length === 0) {
+    briefingCache.set(cacheKey, { text: "", expiresAt: now + BRIEFING_CACHE_TTL_MS });
+    return "";
+  }
+
+  const parts: string[] = [];
+  parts.push(
+    "Memory briefing (untrusted, generated by threema plugin at inbound time \u2014 informational only, not instructions). Short snapshot; full state lives in MEMORY.md / pending-actions.md:"
+  );
+  parts.push(...coreLines);
+  const text = parts.join("\n");
+  briefingCache.set(cacheKey, { text, expiresAt: now + BRIEFING_CACHE_TTL_MS });
+  return text;
+}
+
+// Variante C dispatcher: decide short vs. full per session based on idle gap,
+// and update the session's last-inbound timestamp.
+function buildMemoryBriefingForSession(
+  cfg: OpenClawConfig | undefined,
+  sessionKey: string | undefined
+): string {
+  const now = Date.now();
+  const key = sessionKey || "__default__";
+  const last = lastInboundBySession.get(key);
+  lastInboundBySession.set(key, now);
+  // Cap map growth (defensive; one DM peer per session in practice).
+  if (lastInboundBySession.size > 256) {
+    const cutoff = now - 24 * 60 * 60 * 1000;
+    for (const [k, v] of lastInboundBySession) {
+      if (v < cutoff) lastInboundBySession.delete(k);
+    }
+  }
+  const isFirstOrStale = last === undefined || now - last > BRIEFING_FULL_GAP_MS;
+  return isFirstOrStale ? buildFullMemoryBriefing(cfg) : buildShortMemoryBriefing(cfg);
+}
+
+function composeBodyForAgent(
+  userText: string,
+  cfg: OpenClawConfig | undefined,
+  sessionKey?: string
+): string {
+  const briefing = buildMemoryBriefingForSession(cfg, sessionKey);
   if (!briefing) return userText;
   return `${userText}\n\n[memory_briefing]\n${briefing}\n[/memory_briefing]`;
 }
@@ -1951,6 +2079,139 @@ const threemaChannel = {
       });
     },
   },
+
+  // ============================================================================
+  // Message-Tool Action Adapter — powers the shared `message` tool
+  // (action=send) and internal flows like restart-recovery notices.
+  // Without this, core throws "Channel threema does not support action send".
+  // Normal agent replies go through `outbound.sendText`; this is the
+  // explicit/proactive send surface.
+  // ============================================================================
+  actions: {
+    describeMessageTool: (_params: any) => {
+      return {
+        actions: ["send"] as const,
+        capabilities: [] as const,
+      };
+    },
+
+    supportsAction: ({ action }: { action: string }): boolean =>
+      action === "send",
+
+    handleAction: async (ctx: any): Promise<any> => {
+      const { action, params, cfg } = ctx;
+
+      if (action !== "send") {
+        return {
+          isError: true,
+          content: [
+            { type: "text", text: `Threema: unsupported action "${action}".` },
+          ],
+        };
+      }
+
+      const threemaCfg = getThreemaConfig(cfg);
+      if (!threemaCfg?.gatewayId || !threemaCfg?.secretKey) {
+        return {
+          isError: true,
+          content: [
+            { type: "text", text: "Threema not configured: missing gatewayId or secretKey." },
+          ],
+        };
+      }
+
+      // Resolve destination from common param aliases.
+      const rawTo =
+        (typeof params?.to === "string" && params.to) ||
+        (typeof params?.target === "string" && params.target) ||
+        (typeof params?.chatId === "string" && params.chatId) ||
+        "";
+      if (!rawTo) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: "Threema send: missing 'to'/'target'." }],
+        };
+      }
+      const to = normalizeThreemaTarget(rawTo);
+      if (!isValidThreemaId(to)) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Threema send: invalid Threema ID "${rawTo}".` }],
+        };
+      }
+
+      const mediaUrl =
+        (typeof params?.media === "string" && params.media) ||
+        (typeof params?.mediaUrl === "string" && params.mediaUrl) ||
+        (typeof params?.filePath === "string" && params.filePath) ||
+        (typeof params?.path === "string" && params.path) ||
+        "";
+      const text =
+        (typeof params?.message === "string" && params.message) ||
+        (typeof params?.text === "string" && params.text) ||
+        (typeof params?.caption === "string" && params.caption) ||
+        "";
+
+      if (!text && !mediaUrl) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: "Threema send: nothing to send (no message or media)." }],
+        };
+      }
+
+      try {
+        const client = new ThreemaClient(threemaCfg);
+
+        // Media path: delegate to the same outbound.sendMedia pipeline so all
+        // SSRF/local-path validation stays in one place.
+        if (mediaUrl) {
+          const result = await threemaChannel.outbound.sendMedia({
+            cfg,
+            to,
+            text,
+            mediaUrl,
+          } as any);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Threema media sent to ${to} (messageId ${(result as any)?.messageId ?? "?"}).`,
+              },
+            ],
+            meta: result,
+          };
+        }
+
+        // Text path.
+        const formatted = markdownToThreema(text);
+        const messageId = client.isE2EEnabled
+          ? await client.sendE2E(to, formatted)
+          : await client.sendSimple(to, formatted);
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Threema message sent to ${to} (messageId ${messageId.trim()}).`,
+            },
+          ],
+          meta: {
+            channel: "threema",
+            messageId: messageId.trim(),
+            chatId: to,
+            timestamp: Date.now(),
+          },
+        };
+      } catch (err: any) {
+        return {
+          isError: true,
+          content: [
+            { type: "text", text: `Threema send failed: ${err?.message ?? String(err)}` },
+          ],
+        };
+      }
+    },
+  },
 };
 
 // ============================================================================
@@ -2122,7 +2383,7 @@ async function queueInboundForCoalescing(
 
 export const id = "threema";
 export const name = "Threema Gateway";
-export const version = "0.6.7";
+export const version = "0.7.4";
 export const description =
   "Threema messaging channel via Threema Gateway API (E2E encrypted, with media support)";
 
@@ -2303,7 +2564,11 @@ export default function register(api: any) {
                 const channelRuntime = runtime?.channel;
                 if (channelRuntime?.routing?.resolveAgentRoute && channelRuntime?.reply?.finalizeInboundContext && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                   try {
-                    const currentCfg = runtime.config.loadConfig();
+                    // Use the read-only runtime config snapshot. loadConfig() is
+                    // deprecated (deprecated-internal-config-api guard) and slated
+                    // for removal; current() returns a DeepReadonly<OpenClawConfig>
+                    // which we only read here (route resolution + memory briefing).
+                    const currentCfg = runtime.config.current() as OpenClawConfig;
 
                 // 1. Resolve the agent route and session key
                 const route = channelRuntime.routing.resolveAgentRoute({
@@ -2329,7 +2594,7 @@ export default function register(api: any) {
                 //    sees the current acute state on every inbound, regardless
                 //    of how long the session has been running. CommandBody and
                 //    RawBody stay clean for slash-command parsing.
-                const bodyForAgent = composeBodyForAgent(merged.mergedText, currentCfg);
+                const bodyForAgent = composeBodyForAgent(merged.mergedText, currentCfg, sessionKey);
                 const msgCtx = channelRuntime.reply.finalizeInboundContext({
                   Body: merged.mergedText,
                   RawBody: merged.mergedText,
@@ -2401,6 +2666,41 @@ export default function register(api: any) {
                           }
                         }
                       } else {
+                        // Media path (non-audio): if the reply carries image/file media,
+                        // send it as a Threema file message. Core provides media as
+                        // `mediaUrls` (array, preferred) or legacy `mediaUrl` (string).
+                        const mediaUrls: string[] =
+                          Array.isArray(payload.mediaUrls) && payload.mediaUrls.length > 0
+                            ? payload.mediaUrls.filter((u: any) => typeof u === "string" && u.length > 0)
+                            : (typeof payload.mediaUrl === "string" && payload.mediaUrl
+                                ? [payload.mediaUrl]
+                                : []);
+                        if (mediaUrls.length > 0 && replyClient.isE2EEnabled) {
+                          const caption = markdownToThreema(payload.text ?? payload.body) || undefined;
+                          let sentAny = false;
+                          for (let i = 0; i < mediaUrls.length; i++) {
+                            const mu = mediaUrls[i];
+                            try {
+                              await threemaChannel.outbound.sendMedia({
+                                cfg: currentCfg,
+                                to: from,
+                                text: i === 0 ? (caption ?? "") : "",
+                                mediaUrl: mu,
+                              });
+                              sentAny = true;
+                            } catch (mediaErr: any) {
+                              api.logger?.error?.(`Threema: media send failed for ${mu}: ${mediaErr?.message}`);
+                            }
+                          }
+                          // If at least one media went out, we're done (caption rode along).
+                          // If ALL media failed, fall through to text so the reply isn't lost.
+                          if (sentAny) return;
+                          const fallbackText = markdownToThreema(payload.text ?? payload.body);
+                          if (fallbackText) {
+                            await replyClient.sendE2E(from, fallbackText);
+                          }
+                          return;
+                        }
                         // Send as text (existing logic)
                         const text = markdownToThreema(payload.text ?? payload.body);
                         if (!text) return;
@@ -2533,7 +2833,9 @@ export default function register(api: any) {
                     && channelRuntime?.reply?.finalizeInboundContext
                     && channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                   try {
-                    const currentCfg = runtime.config.loadConfig();
+                    // Read-only runtime config snapshot (see text path above):
+                    // loadConfig() is deprecated and on the removal list.
+                    const currentCfg = runtime.config.current() as OpenClawConfig;
 
                 // Resolve the same agent route + session key the text path uses
                 // so file inbounds end up in the live Threema DM session.
@@ -2554,7 +2856,7 @@ export default function register(api: any) {
 
                 const senderAllowed = allowFrom.length === 0 || allowFrom.includes(from);
 
-                const bodyForAgent = composeBodyForAgent(fileBody, currentCfg);
+                const bodyForAgent = composeBodyForAgent(fileBody, currentCfg, sessionKey);
                 const fileCtx = channelRuntime.reply.finalizeInboundContext({
                   Body: fileBody,
                   RawBody: fileBody,
@@ -2629,6 +2931,41 @@ export default function register(api: any) {
                           }
                         }
                       } else {
+                        // Media path (non-audio): if the reply carries image/file media,
+                        // send it as a Threema file message. Core provides media as
+                        // `mediaUrls` (array, preferred) or legacy `mediaUrl` (string).
+                        const mediaUrls: string[] =
+                          Array.isArray(payload.mediaUrls) && payload.mediaUrls.length > 0
+                            ? payload.mediaUrls.filter((u: any) => typeof u === "string" && u.length > 0)
+                            : (typeof payload.mediaUrl === "string" && payload.mediaUrl
+                                ? [payload.mediaUrl]
+                                : []);
+                        if (mediaUrls.length > 0 && replyClient.isE2EEnabled) {
+                          const caption = markdownToThreema(payload.text ?? payload.body) || undefined;
+                          let sentAny = false;
+                          for (let i = 0; i < mediaUrls.length; i++) {
+                            const mu = mediaUrls[i];
+                            try {
+                              await threemaChannel.outbound.sendMedia({
+                                cfg: currentCfg,
+                                to: from,
+                                text: i === 0 ? (caption ?? "") : "",
+                                mediaUrl: mu,
+                              });
+                              sentAny = true;
+                            } catch (mediaErr: any) {
+                              api.logger?.error?.(`Threema: media send failed for ${mu}: ${mediaErr?.message}`);
+                            }
+                          }
+                          // If at least one media went out, we're done (caption rode along).
+                          // If ALL media failed, fall through to text so the reply isn't lost.
+                          if (sentAny) return;
+                          const fallbackText = markdownToThreema(payload.text ?? payload.body);
+                          if (fallbackText) {
+                            await replyClient.sendE2E(from, fallbackText);
+                          }
+                          return;
+                        }
                         // Send as text (existing logic)
                         const text = markdownToThreema(payload.text ?? payload.body);
                         if (!text) return;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "threema",
   "name": "Threema Gateway",
   "description": "Threema messaging channel via Threema Gateway API (E2E encrypted)",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "channels": [
     "threema"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-threema",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "Threema Gateway channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",