@syengup/friday-channel-next 0.1.13 → 0.1.14

package/dist/src/agent-forward-runtime.d.ts

@@ -8,6 +8,12 @@ export type FridayAgentForwardRuntime = {
         maintenanceConfig?: unknown;
         clone?: boolean;
     }) => Record<string, unknown>;
+    /** Cache-owning entry write (syncs the app session name → server `displayName`). */
+    updateSessionStoreEntry?: (params: {
+        storePath: string;
+        sessionKey: string;
+        update: (entry: Record<string, unknown>) => Record<string, unknown> | null | Promise<Record<string, unknown> | null>;
+    }) => Promise<Record<string, unknown> | null>;
     getConfig: () => unknown;
 };
 /** Called from `registerFull` so terminal lifecycle forwards can read `sessions.json` after persist. */

package/dist/src/agent-forward-runtime.js

@@ -4,6 +4,8 @@ export function setFridayAgentForwardRuntime(api) {
     forwardRuntime = {
         resolveStorePath: api.runtime.agent.session.resolveStorePath,
         loadSessionStore: api.runtime.agent.session.loadSessionStore,
+        updateSessionStoreEntry: api.runtime.agent.session
+            .updateSessionStoreEntry,
         getConfig: () => api.runtime.config.current(),
     };
 }

package/dist/src/channel-actions.js

@@ -2,6 +2,8 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import { sseEmitter } from "./sse/emitter.js";
 import { guessMimeType } from "./http/handlers/files.js";
+import { getRunRoute } from "./run-metadata.js";
+import { resolveHistorySessionKeyForFridayDevice } from "./friday-session.js";
 const DISCOVERY = {
     actions: ["send", "channel-info", "channel-list"],
     capabilities: ["text", "media"],
@@ -48,7 +50,13 @@ async function handleSend(ctx) {
         return { ok: false, error: "Missing required param: to" };
     }
     const runId = crypto.randomUUID();
-    const sessionKey = ctx.sessionKey ?? undefined;
+    // The `message` tool's send runs as a fresh action; `ctx.sessionKey` is the agent's base/main
+    // session, not the app session that started the active run on this device. Recover the latter via
+    // the device's last tracked run-route so attachments land in the user's current session.
+    const activeRunId = sseEmitter.getLastRunIdForDevice(to) ?? undefined;
+    const sessionKey = (activeRunId ? getRunRoute(activeRunId)?.sessionKey : undefined) ??
+        ctx.sessionKey ??
+        resolveHistorySessionKeyForFridayDevice(to);
     // Send text via SSE outbound
     if (text) {
         sseEmitter.broadcast({

package/dist/src/channel.js

@@ -14,6 +14,7 @@ import { sseEmitter } from "./sse/emitter.js";
 import { describeMessageActions, handleMessageAction } from "./channel-actions.js";
 import { guessMimeType, resolveMediaAttachment } from "./http/handlers/files.js";
 import { resolveFridayDeviceIdForOutbound, resolveHistorySessionKeyForFridayDevice, } from "./friday-session.js";
+import { getRunRoute } from "./run-metadata.js";
 import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
 const logger = createFridayNextLogger("channel");
 const CHANNEL_ID = "friday-next";
@@ -25,6 +26,20 @@ function pickFirstString(source, keys) {
     }
     return undefined;
 }
+/**
+ * Resolve the sessionKey for an outbound message-tool send.
+ *
+ * OpenClaw's `ChannelOutboundContext` does not carry the originating run's sessionKey, so the raw
+ * ctx is almost always missing it. We recover the current run's session via the run-route registry
+ * (keyed by the device's last tracked runId) so message-tool text/media land in the session that
+ * triggered the run — not a device-level fallback. Falls back to the device's latest history session
+ * for cron / offline / no-run paths.
+ */
+function resolveOutboundSessionKey(deviceId, runId, rawCtx) {
+    return ((runId ? getRunRoute(runId)?.sessionKey : undefined) ??
+        pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
+        resolveHistorySessionKeyForFridayDevice(deviceId));
+}
 function resolveLocalMediaPath(mediaUrl, localRoots) {
     if (path.isAbsolute(mediaUrl))
         return mediaUrl;
@@ -138,8 +153,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
                 "runId",
             ]);
             const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
-            const sessionKey = pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
-                resolveHistorySessionKeyForFridayDevice(deviceId);
+            const sessionKey = resolveOutboundSessionKey(deviceId, runId, rawCtx);
             const conn = sseEmitter.getConnection(deviceId);
             const ts = new Date().toISOString();
             logger.info(`[SEND_TEXT] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} textLen=${text.length} online=${!!conn}`);
@@ -178,8 +192,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
                 "runId",
             ]);
             const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
-            const sessionKey = pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
-                resolveHistorySessionKeyForFridayDevice(deviceId);
+            const sessionKey = resolveOutboundSessionKey(deviceId, runId, rawCtx);
             const audioAsVoice = ctx.audioAsVoice === true;
             const caption = ctx.text ?? "";
             if (!mediaUrl) {

package/dist/src/history/normalize-message.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Normalizes raw OpenClaw session transcript messages (as returned by the
+ * gateway `sessions.get` method / `runtime.subagent.getSessionMessages`) into a
+ * stable wire DTO the Friday app can parse without guessing at the upstream
+ * content-block shape.
+ *
+ * Each raw message is one persisted LLM message (UserMessage / AssistantMessage
+ * / ToolResultMessage) with an `__openclaw` metadata envelope attached by the
+ * gateway carrying the stable transcript entry `id`, a positional `seq`, and the
+ * record timestamp. That `id` is the durable, channel-agnostic identity the app
+ * uses as its sync/dedup key — runId is NOT persisted upstream.
+ */
+export interface FridayHistoryImage {
+    mimeType?: string;
+    /** Base64 payload for inline ImageContent blocks. */
+    data?: string;
+    /** URL for `[media attached: ...]` markers or resolved `MEDIA:` attachments. */
+    url?: string;
+    /** Display/download filename (set for resolved `MEDIA:` attachments). */
+    filename?: string;
+}
+export interface FridayHistoryToolCall {
+    id: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface FridayHistoryToolResult {
+    toolCallId?: string;
+    toolName?: string;
+    isError?: boolean;
+    text?: string;
+    images?: FridayHistoryImage[];
+}
+export interface FridayHistoryUsage {
+    totalTokens?: number;
+    input?: number;
+    output?: number;
+}
+export type FridayHistoryRole = "user" | "assistant" | "toolResult" | "system";
+export interface FridayHistoryMessage {
+    /** Stable transcript entry id (sync key). Synthetic when upstream omitted it. */
+    id: string;
+    seq: number;
+    ts?: number;
+    role: FridayHistoryRole;
+    text?: string;
+    thinking?: string;
+    toolCalls?: FridayHistoryToolCall[];
+    toolResult?: FridayHistoryToolResult;
+    images?: FridayHistoryImage[];
+    /** Raw `MEDIA:<path>` server paths stripped from text; the handler resolves
+     *  them to downloadable `/friday-next/files/...` attachment URLs. */
+    mediaPaths?: string[];
+    model?: string;
+    usage?: FridayHistoryUsage;
+    /** Non-message records surfaced for context (e.g. compaction dividers). */
+    kind?: "compaction";
+    /** True when `id` was synthesized because upstream had no stable id. */
+    synthetic?: boolean;
+}
+/**
+ * Normalize one raw transcript message. `index` is the position in the returned
+ * batch, used only to synthesize a stable-ish id when upstream omits one.
+ */
+export declare function normalizeHistoryMessage(raw: unknown, index: number): FridayHistoryMessage | null;
+/** Normalize a batch of raw transcript messages, dropping unparseable entries. */
+export declare function normalizeHistoryMessages(rawMessages: unknown[]): FridayHistoryMessage[];

package/dist/src/history/normalize-message.js

@@ -0,0 +1,224 @@
+/**
+ * Normalizes raw OpenClaw session transcript messages (as returned by the
+ * gateway `sessions.get` method / `runtime.subagent.getSessionMessages`) into a
+ * stable wire DTO the Friday app can parse without guessing at the upstream
+ * content-block shape.
+ *
+ * Each raw message is one persisted LLM message (UserMessage / AssistantMessage
+ * / ToolResultMessage) with an `__openclaw` metadata envelope attached by the
+ * gateway carrying the stable transcript entry `id`, a positional `seq`, and the
+ * record timestamp. That `id` is the durable, channel-agnostic identity the app
+ * uses as its sync/dedup key — runId is NOT persisted upstream.
+ */
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const n = Number(value);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return undefined;
+}
+/** `MEDIA:<path>` lines emitted for outbound attachments (e.g. generated images). */
+const MEDIA_LINE_RE = /^[ \t]*MEDIA:[ \t]*(\S.*?)[ \t]*$/gim;
+/** Strips `MEDIA:<path>` lines from text, returning the cleaned text + the paths. */
+function splitMediaLines(text) {
+    if (!text.includes("MEDIA:"))
+        return { text, paths: [] };
+    const paths = [];
+    const cleaned = text
+        .replace(MEDIA_LINE_RE, (_m, p) => {
+        const v = p.trim();
+        if (v)
+            paths.push(v);
+        return "";
+    })
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    return { text: cleaned, paths };
+}
+const MEDIA_MARKER_RE = /\[media attached:\s*([^\]]+)\]/gi;
+/** Pull `[media attached: <url>]` markers out of free text into image refs. */
+function extractMediaMarkers(text) {
+    const images = [];
+    for (const match of text.matchAll(MEDIA_MARKER_RE)) {
+        const url = match[1]?.trim();
+        if (url)
+            images.push({ url });
+    }
+    return images;
+}
+function parseContent(content) {
+    const out = { text: "", thinking: "", toolCalls: [], images: [] };
+    if (typeof content === "string") {
+        out.text = content;
+        out.images.push(...extractMediaMarkers(content));
+        return out;
+    }
+    if (!Array.isArray(content))
+        return out;
+    const textParts = [];
+    const thinkingParts = [];
+    for (const rawBlock of content) {
+        const block = asRecord(rawBlock);
+        if (!block)
+            continue;
+        switch (block.type) {
+            case "text": {
+                const t = readString(block.text);
+                if (t) {
+                    textParts.push(t);
+                    out.images.push(...extractMediaMarkers(t));
+                }
+                break;
+            }
+            case "thinking": {
+                const t = readString(block.thinking);
+                if (t)
+                    thinkingParts.push(t);
+                break;
+            }
+            case "image": {
+                const data = readString(block.data);
+                const url = readString(block.url);
+                // Skip empty image blocks (no payload and no URL) — they'd render as
+                // broken attachment bubbles in the app.
+                if (data || url) {
+                    out.images.push({
+                        ...(readString(block.mimeType) ? { mimeType: readString(block.mimeType) } : {}),
+                        ...(data ? { data } : {}),
+                        ...(url ? { url } : {}),
+                    });
+                }
+                break;
+            }
+            case "toolCall": {
+                const id = readString(block.id);
+                const name = readString(block.name);
+                if (id && name) {
+                    out.toolCalls.push({
+                        id,
+                        name,
+                        ...(asRecord(block.arguments) ? { arguments: asRecord(block.arguments) } : {}),
+                    });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    out.text = textParts.join("");
+    out.thinking = thinkingParts.join("");
+    return out;
+}
+function parseUsage(raw) {
+    const usage = asRecord(raw);
+    if (!usage)
+        return undefined;
+    const totalTokens = readFiniteNumber(usage.totalTokens) ?? readFiniteNumber(usage.total);
+    const input = readFiniteNumber(usage.input);
+    const output = readFiniteNumber(usage.output);
+    if (totalTokens === undefined && input === undefined && output === undefined)
+        return undefined;
+    return {
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(input !== undefined ? { input } : {}),
+        ...(output !== undefined ? { output } : {}),
+    };
+}
+function normalizeRole(raw) {
+    const role = readString(raw)?.toLowerCase();
+    switch (role) {
+        case "user":
+            return "user";
+        case "toolresult":
+            return "toolResult";
+        case "system":
+            return "system";
+        default:
+            return "assistant";
+    }
+}
+/**
+ * Normalize one raw transcript message. `index` is the position in the returned
+ * batch, used only to synthesize a stable-ish id when upstream omits one.
+ */
+export function normalizeHistoryMessage(raw, index) {
+    const record = asRecord(raw);
+    if (!record)
+        return null;
+    const meta = asRecord(record.__openclaw);
+    const role = normalizeRole(record.role);
+    const parsed = parseContent(record.content);
+    const seq = readFiniteNumber(meta?.seq) ?? index + 1;
+    const metaId = readString(meta?.id);
+    const id = metaId ?? `seq:${seq}`;
+    const synthetic = metaId === undefined;
+    const ts = readFiniteNumber(meta?.recordTimestampMs) ?? readFiniteNumber(record.timestamp);
+    const kind = readString(meta?.kind) === "compaction" ? "compaction" : undefined;
+    const message = {
+        id,
+        seq,
+        role,
+        ...(ts !== undefined ? { ts } : {}),
+        ...(synthetic ? { synthetic: true } : {}),
+        ...(kind ? { kind } : {}),
+    };
+    if (kind === "compaction") {
+        message.text = parsed.text || "Compaction";
+        return message;
+    }
+    if (role === "toolResult") {
+        const split = splitMediaLines(parsed.text);
+        const toolResult = {
+            ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
+            ...(readString(record.toolName) ? { toolName: readString(record.toolName) } : {}),
+            ...(record.isError === true ? { isError: true } : {}),
+            ...(split.text ? { text: split.text } : {}),
+            ...(parsed.images.length ? { images: parsed.images } : {}),
+        };
+        message.toolResult = toolResult;
+        if (split.paths.length)
+            message.mediaPaths = split.paths;
+        return message;
+    }
+    const split = splitMediaLines(parsed.text);
+    if (split.text)
+        message.text = split.text;
+    if (split.paths.length)
+        message.mediaPaths = split.paths;
+    if (parsed.thinking)
+        message.thinking = parsed.thinking;
+    if (parsed.toolCalls.length)
+        message.toolCalls = parsed.toolCalls;
+    if (parsed.images.length)
+        message.images = parsed.images;
+    const model = readString(record.model) ?? readString(record.responseModel);
+    if (model)
+        message.model = model;
+    const usage = parseUsage(record.usage);
+    if (usage)
+        message.usage = usage;
+    return message;
+}
+/** Normalize a batch of raw transcript messages, dropping unparseable entries. */
+export function normalizeHistoryMessages(rawMessages) {
+    const out = [];
+    for (let i = 0; i < rawMessages.length; i += 1) {
+        const normalized = normalizeHistoryMessage(rawMessages[i], i);
+        if (normalized)
+            out.push(normalized);
+    }
+    out.sort((a, b) => a.seq - b.seq);
+    return out;
+}

package/dist/src/history/read-transcript.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Reads a session's transcript directly from disk via the forward runtime's
+ * session store (`sessions.json` → entry.sessionFile → the `.jsonl` transcript).
+ *
+ * We do NOT use `runtime.subagent.getSessionMessages` here: that dispatches the
+ * gateway `sessions.get` method which is only valid inside a gateway request
+ * scope and returns empty when called from a plugin HTTP route. Reading the
+ * transcript file mirrors how `history-sessions.ts` reads `sessions.json`.
+ *
+ * Each transcript line is `{type, id, parentId, timestamp, message:{role,content,...}}`.
+ * We surface message records (in file order) with an `__openclaw` envelope
+ * matching the gateway's own `sessions.get` output, so `normalize-message.ts`
+ * can consume either source identically.
+ */
+export declare function resolveTranscriptPath(entry: unknown, storePath: string): string | undefined;
+/** Resolves the real server-side session id for a session key, or undefined. */
+export declare function resolveSessionId(sessionKey: string): string | undefined;
+/**
+ * Returns raw transcript message objects (newest tail up to `limit`), each with
+ * an `__openclaw: { id, seq, recordTimestampMs }` envelope. Empty on any failure.
+ */
+export declare function readSessionTranscriptRawMessages(sessionKey: string, limit: number): unknown[];

package/dist/src/history/read-transcript.js

@@ -0,0 +1,136 @@
+/**
+ * Reads a session's transcript directly from disk via the forward runtime's
+ * session store (`sessions.json` → entry.sessionFile → the `.jsonl` transcript).
+ *
+ * We do NOT use `runtime.subagent.getSessionMessages` here: that dispatches the
+ * gateway `sessions.get` method which is only valid inside a gateway request
+ * scope and returns empty when called from a plugin HTTP route. Reading the
+ * transcript file mirrors how `history-sessions.ts` reads `sessions.json`.
+ *
+ * Each transcript line is `{type, id, parentId, timestamp, message:{role,content,...}}`.
+ * We surface message records (in file order) with an `__openclaw` envelope
+ * matching the gateway's own `sessions.get` output, so `normalize-message.ts`
+ * can consume either source identically.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getFridayAgentForwardRuntime } from "../agent-forward-runtime.js";
+import { agentIdFromSessionKey, toSessionStoreKey } from "../session/session-manager.js";
+function entryString(entry, key) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const v = entry[key];
+    return typeof v === "string" && v.trim() ? v : undefined;
+}
+/**
+ * Resolves the store entry for a session key, tolerating case differences
+ * (the app's key carries an upper-case deviceId; `sessions.json` stores it
+ * lower-cased).
+ */
+function resolveEntry(store, sessionKey) {
+    if (store[sessionKey])
+        return store[sessionKey];
+    const canonical = toSessionStoreKey(sessionKey);
+    if (store[canonical])
+        return store[canonical];
+    const target = canonical.toLowerCase();
+    for (const [k, v] of Object.entries(store)) {
+        if (k.toLowerCase() === target)
+            return v;
+    }
+    return undefined;
+}
+export function resolveTranscriptPath(entry, storePath) {
+    const sessionFile = entryString(entry, "sessionFile");
+    if (sessionFile) {
+        return path.isAbsolute(sessionFile)
+            ? sessionFile
+            : path.join(path.dirname(storePath), sessionFile);
+    }
+    const sessionId = entryString(entry, "sessionId");
+    if (sessionId) {
+        return path.join(path.dirname(storePath), `${sessionId}.jsonl`);
+    }
+    return undefined;
+}
+/** Resolves the real server-side session id for a session key, or undefined. */
+export function resolveSessionId(sessionKey) {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt)
+        return undefined;
+    const agentId = agentIdFromSessionKey(sessionKey);
+    try {
+        const store = rt.loadSessionStore(rt.resolveStorePath(undefined, { agentId })) ?? {};
+        return entryString(resolveEntry(store, sessionKey), "sessionId");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Returns raw transcript message objects (newest tail up to `limit`), each with
+ * an `__openclaw: { id, seq, recordTimestampMs }` envelope. Empty on any failure.
+ */
+export function readSessionTranscriptRawMessages(sessionKey, limit) {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt)
+        return [];
+    const agentId = agentIdFromSessionKey(sessionKey);
+    let storePath;
+    let store;
+    try {
+        storePath = rt.resolveStorePath(undefined, { agentId });
+        store = rt.loadSessionStore(storePath) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const entry = resolveEntry(store, sessionKey);
+    if (!entry)
+        return [];
+    const filePath = resolveTranscriptPath(entry, storePath);
+    if (!filePath)
+        return [];
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const raw = [];
+    let seq = 0;
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let rec;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                continue;
+            rec = parsed;
+        }
+        catch {
+            continue;
+        }
+        if (rec.type === "session" || !rec.message || typeof rec.message !== "object")
+            continue;
+        seq += 1;
+        const tsRaw = rec.timestamp;
+        const ts = typeof tsRaw === "string"
+            ? Date.parse(tsRaw)
+            : typeof tsRaw === "number"
+                ? tsRaw
+                : Number.NaN;
+        raw.push({
+            ...rec.message,
+            __openclaw: {
+                ...(typeof rec.id === "string" ? { id: rec.id } : {}),
+                seq,
+                ...(Number.isFinite(ts) ? { recordTimestampMs: ts } : {}),
+            },
+        });
+    }
+    return limit > 0 && raw.length > limit ? raw.slice(raw.length - limit) : raw;
+}

package/dist/src/http/handlers/files.d.ts

@@ -1,10 +1,11 @@
 /**
  * File manager for Friday Next channel attachments.
  *
- * Files are copied under the plugin root `attachments/` and served at
+ * Files are copied under `~/.openclaw/friday-next/attachments/` and served at
  * GET /friday-next/files/{token} so the app can use stable gateway URLs after restarts.
  */
-/** Plugin-root `attachments/` directory; created on first use. */
+export declare function setAttachmentsDirForTest(dir: string | null): void;
+/** `~/.openclaw/friday-next/attachments/` directory; created on first use. */
 export declare function getAttachmentsDir(): string;
 export interface StoredFile {
     id: string;

package/dist/src/http/handlers/files.js

@@ -1,7 +1,7 @@
 /**
  * File manager for Friday Next channel attachments.
  *
- * Files are copied under the plugin root `attachments/` and served at
+ * Files are copied under `~/.openclaw/friday-next/attachments/` and served at
  * GET /friday-next/files/{token} so the app can use stable gateway URLs after restarts.
  */
 import crypto from "node:crypto";
@@ -10,12 +10,27 @@ import os from "node:os";
 import { createFridayNextLogger } from "../../logging.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-function getPluginRootDir() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+import { resolveFridayNextConfig } from "../../config.js";
+import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
+import { getFridayNextRuntime } from "../../runtime.js";
+/** Test-only override for the attachments base directory. */
+let testAttachmentsDir = null;
+export function setAttachmentsDirForTest(dir) {
+    testAttachmentsDir = dir;
 }
-/** Plugin-root `attachments/` directory; created on first use. */
+/** Resolve `<historyDir>/../attachments`, mirroring the offline-queue layout. */
+function resolveAttachmentsDir() {
+    try {
+        const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+        return path.join(path.dirname(cfg.historyDir), "attachments");
+    }
+    catch {
+        return path.join(os.homedir(), ".openclaw", "friday-next", "attachments");
+    }
+}
+/** `~/.openclaw/friday-next/attachments/` directory; created on first use. */
 export function getAttachmentsDir() {
-    const dir = path.join(getPluginRootDir(), "attachments");
+    const dir = testAttachmentsDir ?? resolveAttachmentsDir();
     try {
         fs.mkdirSync(dir, { recursive: true });
     }

package/dist/src/http/handlers/history-messages.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+ *
+ * Returns a session's transcript history as a flat, normalized message stream.
+ * The Friday app groups these into rounds itself (by role transitions) and uses
+ * each message's stable `id` (the upstream transcript entry id) as its sync key.
+ *
+ * Reads via the gateway `sessions.get` method (exposed to plugins as
+ * `runtime.subagent.getSessionMessages`), which already resolves the active
+ * branch and compaction, then normalizes each raw message into a stable DTO.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleHistoryMessages(req: IncomingMessage, res: ServerResponse): Promise<boolean>;