@syengup/friday-channel-next 0.1.12 → 0.1.14

package/dist/src/http/handlers/history-messages.js

@@ -0,0 +1,100 @@
+/**
+ * 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 { getFridayNextRuntime } from "../../runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { normalizeHistoryMessages } from "../../history/normalize-message.js";
+import { readSessionTranscriptRawMessages, resolveSessionId } from "../../history/read-transcript.js";
+import { resolveMediaAttachment } from "./files.js";
+const DEFAULT_LIMIT = 200;
+const MAX_LIMIT = 1000;
+function resolveSubagentApi() {
+    try {
+        const runtime = getFridayNextRuntime();
+        return runtime.subagent;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function handleHistoryMessages(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const sessionKey = url.searchParams.get("sessionKey")?.trim();
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required query param: sessionKey" }));
+        return true;
+    }
+    const agentId = url.searchParams.get("agentId")?.trim() || undefined;
+    const limitParam = Number(url.searchParams.get("limit"));
+    const limit = Number.isFinite(limitParam) && limitParam > 0
+        ? Math.min(Math.floor(limitParam), MAX_LIMIT)
+        : DEFAULT_LIMIT;
+    // Primary path: read the transcript file directly (works from an HTTP route).
+    let rawMessages = readSessionTranscriptRawMessages(sessionKey, limit);
+    // Fallback: the request-scoped gateway method (only works in some contexts).
+    if (rawMessages.length === 0) {
+        const sessionApi = resolveSubagentApi();
+        if (sessionApi?.getSessionMessages) {
+            try {
+                const response = await sessionApi.getSessionMessages({ sessionKey, limit });
+                rawMessages = Array.isArray(response?.messages) ? response.messages : [];
+            }
+            catch {
+                // Best-effort: an unreadable/unknown session yields an empty history
+                // rather than an error, so the app degrades gracefully.
+                rawMessages = [];
+            }
+        }
+    }
+    const messages = normalizeHistoryMessages(rawMessages);
+    // Resolve `MEDIA:<server-path>` references into downloadable attachment URLs
+    // (copies the file into the plugin's attachments/ dir — the same mechanism the
+    // live deliver path uses), then drop the raw paths from the wire.
+    for (const message of messages) {
+        if (!message.mediaPaths?.length)
+            continue;
+        const resolved = message.mediaPaths
+            .map((p) => resolveMediaAttachment(p))
+            .filter((r) => Boolean(r))
+            .map((r) => ({ url: r.url, filename: r.fileName }));
+        if (resolved.length) {
+            message.images = [...(message.images ?? []), ...resolved];
+        }
+        delete message.mediaPaths;
+    }
+    const sessionId = resolveSessionId(sessionKey);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({
+        ok: true,
+        sessionKey,
+        ...(agentId ? { agentId } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        totalMessages: messages.length,
+        messages,
+    }));
+    return true;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * GET /friday-next/history/sessions
+ *
+ * Lists every session across every configured agent (lightweight metadata only).
+ * The Friday app uses this to surface sessions created on other platforms /
+ * channels in its sidebar before lazily fetching each session's history.
+ *
+ * Session message bodies are intentionally NOT read here — that is the job of the
+ * per-session history endpoint. We only read each agent's `sessions.json` via the
+ * forward runtime (`loadSessionStore`), matching the read path already used for
+ * terminal lifecycle forwards.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface FridayHistorySessionSummary {
+    /** Canonical app session key, e.g. "agent:main:main". */
+    sessionKey: string;
+    agentId: string;
+    sessionId?: string;
+    updatedAt?: number;
+    model?: string;
+    title?: string;
+}
+export declare function handleHistorySessions(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/history-sessions.js

@@ -0,0 +1,163 @@
+/**
+ * GET /friday-next/history/sessions
+ *
+ * Lists every session across every configured agent (lightweight metadata only).
+ * The Friday app uses this to surface sessions created on other platforms /
+ * channels in its sidebar before lazily fetching each session's history.
+ *
+ * Session message bodies are intentionally NOT read here — that is the job of the
+ * per-session history endpoint. We only read each agent's `sessions.json` via the
+ * forward runtime (`loadSessionStore`), matching the read path already used for
+ * terminal lifecycle forwards.
+ */
+import fs from "node:fs";
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { resolveTranscriptPath } from "../../history/read-transcript.js";
+const DEFAULT_AGENT_ID = "main";
+const SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]*$/;
+/** Mirror of OpenClaw's `normalizeAgentId` (also used in agents-list.ts). */
+function normalizeAgentId(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed)
+        return DEFAULT_AGENT_ID;
+    const lowered = trimmed.toLowerCase();
+    if (SAFE_AGENT_ID.test(lowered))
+        return lowered;
+    return (lowered
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || DEFAULT_AGENT_ID);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Configured agent ids (deduped). Falls back to the implicit "main" agent. */
+function resolveConfiguredAgentIds(config) {
+    const agents = config?.agents;
+    const list = agents?.list;
+    if (!Array.isArray(list) || list.length === 0)
+        return [DEFAULT_AGENT_ID];
+    const ids = new Set();
+    for (const agent of list) {
+        if (agent && typeof agent === "object")
+            ids.add(normalizeAgentId(agent.id));
+    }
+    if (ids.size === 0)
+        ids.add(DEFAULT_AGENT_ID);
+    return [...ids];
+}
+/** Build the canonical app session key from an agent + a raw sessions.json key. */
+function toCanonicalSessionKey(agentId, storeKey) {
+    const key = storeKey.trim();
+    if (key.toLowerCase().startsWith("agent:"))
+        return key;
+    return `agent:${agentId}:${key}`;
+}
+/** Session-id portion (everything after `agent:<id>:`). */
+function sessionRest(canonicalKey) {
+    const m = canonicalKey.match(/^agent:[^:]+:(.+)$/);
+    return (m?.[1] ?? canonicalKey).toLowerCase();
+}
+/**
+ * Internal/system sessions that aren't user-facing conversations — mirrors what
+ * OpenClaw's own `sessions.list` filters (cron/global/unknown/phantom) plus
+ * heartbeat / subagent / memory-dreaming runs.
+ */
+function isInternalSessionKey(canonicalKey, storeKey) {
+    const k = storeKey.toLowerCase();
+    if (k === "global" || k === "unknown")
+        return true;
+    const rest = sessionRest(canonicalKey);
+    return (rest === "sessions" || // phantom agent-store entry
+        rest.startsWith("subagent:") ||
+        rest.startsWith("cron:") ||
+        rest.startsWith("dreaming-narrative") ||
+        rest === "heartbeat" ||
+        rest.endsWith(":heartbeat"));
+}
+/** A session counts as archived/empty when its transcript file is gone or empty. */
+function hasLiveTranscript(entry, storePath) {
+    const filePath = resolveTranscriptPath(entry, storePath);
+    if (!filePath)
+        return false;
+    try {
+        return fs.statSync(filePath).size > 0;
+    }
+    catch {
+        return false; // archived (moved to .deleted/.bak) or never written
+    }
+}
+function readAgentSessions(agentId) {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt)
+        return [];
+    let storePath;
+    let store;
+    try {
+        storePath = rt.resolveStorePath(undefined, { agentId });
+        store = rt.loadSessionStore(storePath) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const summaries = [];
+    for (const [storeKey, rawEntry] of Object.entries(store)) {
+        if (!rawEntry || typeof rawEntry !== "object")
+            continue;
+        const entry = rawEntry;
+        const canonicalKey = toCanonicalSessionKey(agentId, storeKey);
+        // Drop internal/system sessions and subagent links.
+        if (isInternalSessionKey(canonicalKey, storeKey))
+            continue;
+        if (entry.spawnedBy || entry.subagentRole || entry.parentSessionKey)
+            continue;
+        // Drop archived/empty sessions (transcript moved away or never written).
+        if (!hasLiveTranscript(entry, storePath))
+            continue;
+        summaries.push({
+            sessionKey: canonicalKey,
+            agentId,
+            ...(readString(entry.sessionId) ? { sessionId: readString(entry.sessionId) } : {}),
+            ...(readNumber(entry.updatedAt) !== undefined ? { updatedAt: readNumber(entry.updatedAt) } : {}),
+            ...(readString(entry.model) ?? readString(entry.modelOverride)
+                ? { model: readString(entry.model) ?? readString(entry.modelOverride) }
+                : {}),
+            // Server-side session display name (matches OpenClaw's resolution order).
+            ...(readString(entry.displayName) ?? readString(entry.label)
+                ? { title: readString(entry.displayName) ?? readString(entry.label) }
+                : {}),
+        });
+    }
+    return summaries;
+}
+export async function handleHistorySessions(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const rt = getFridayAgentForwardRuntime();
+    const config = rt?.getConfig();
+    const agentIds = resolveConfiguredAgentIds(config);
+    const sessions = [];
+    for (const agentId of agentIds) {
+        sessions.push(...readAgentSessions(agentId));
+    }
+    sessions.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, sessions }));
+    return true;
+}

package/dist/src/http/handlers/history-set-title.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PUT /friday-next/sessions/title  body: { sessionKey, title }
+ *
+ * Syncs the app-set session name to the server session's `displayName` (the
+ * field OpenClaw resolves first for a session's display title, ahead of `label`).
+ * Writes via `updateSessionStoreEntry` (cache-owning, not request-scoped), so the
+ * change is also visible to webui and other clients.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleHistorySetTitle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/history-set-title.js

@@ -0,0 +1,77 @@
+/**
+ * PUT /friday-next/sessions/title  body: { sessionKey, title }
+ *
+ * Syncs the app-set session name to the server session's `displayName` (the
+ * field OpenClaw resolves first for a session's display title, ahead of `label`).
+ * Writes via `updateSessionStoreEntry` (cache-owning, not request-scoped), so the
+ * change is also visible to webui and other clients.
+ */
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+import { agentIdFromSessionKey, toSessionStoreKey } from "../../session/session-manager.js";
+function json(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+    return true;
+}
+/** Real store key matching `sessionKey`, tolerating deviceId case differences. */
+function resolveStoreKey(store, sessionKey) {
+    if (store[sessionKey])
+        return sessionKey;
+    const canonical = toSessionStoreKey(sessionKey);
+    if (store[canonical])
+        return canonical;
+    const target = canonical.toLowerCase();
+    for (const k of Object.keys(store)) {
+        if (k.toLowerCase() === target)
+            return k;
+    }
+    return undefined;
+}
+export async function handleHistorySetTitle(req, res) {
+    if (req.method !== "PUT" && req.method !== "POST") {
+        return json(res, 405, { error: "Method Not Allowed" });
+    }
+    if (!extractBearerToken(req)) {
+        return json(res, 401, { error: "Unauthorized: bearer token mismatch" });
+    }
+    const body = (await readJsonBody(req));
+    const sessionKey = typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "";
+    const title = typeof body?.title === "string" ? body.title.trim() : "";
+    if (!sessionKey) {
+        return json(res, 400, { error: "Missing required field: sessionKey" });
+    }
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt?.updateSessionStoreEntry) {
+        return json(res, 503, { error: "Session store write not available" });
+    }
+    const agentId = agentIdFromSessionKey(sessionKey);
+    let storePath;
+    let store;
+    try {
+        storePath = rt.resolveStorePath(undefined, { agentId });
+        store = rt.loadSessionStore(storePath) ?? {};
+    }
+    catch {
+        return json(res, 500, { error: "Failed to load session store" });
+    }
+    const storeKey = resolveStoreKey(store, sessionKey);
+    if (!storeKey) {
+        return json(res, 404, { error: `Session not found: ${sessionKey}` });
+    }
+    try {
+        const updated = await rt.updateSessionStoreEntry({
+            storePath,
+            sessionKey: storeKey,
+            // Empty title clears the override so the server can derive its own again.
+            update: () => ({ displayName: title || undefined }),
+        });
+        const sessionId = updated && typeof updated.sessionId === "string" ? updated.sessionId : undefined;
+        return json(res, 200, { ok: true, sessionKey, ...(sessionId ? { sessionId } : {}), title });
+    }
+    catch {
+        return json(res, 500, { error: "Failed to update session title" });
+    }
+}

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

@@ -14,7 +14,7 @@ import { resolveFridayNextConfig } from "../../config.js";
 import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
 import { getFridayNextRuntime } from "../../runtime.js";
 import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
-import { setSessionSettings, splitModelRef, toSessionStoreKey } from "../../session/session-manager.js";
+import { agentIdFromSessionKey, setSessionSettings, splitModelRef, toSessionStoreKey, } from "../../session/session-manager.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { extractBearerToken } from "../middleware/auth.js";
 import { readJsonBody } from "../middleware/body.js";
@@ -315,6 +315,10 @@ export async function handleMessages(req, res) {
     log("MESSAGE_RECEIVED", normalizedDeviceId, runId, `textLen=${trimmedText.length} attachments=${attachments.length} sessionKey=${baseSessionKey}`);
     const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
     // Resolve defaults from the OpenClaw agent config so settings are never left empty.
+    // The target agent comes from the app-supplied sessionKey (`agent:<id>:<rest>`); prefer that
+    // agent's own configured model/thinking over the global defaults so non-main agents are not
+    // silently forced onto the global default model.
+    const targetAgentId = agentIdFromSessionKey(baseSessionKey);
     let defaultModel;
     let defaultThinking;
     try {
@@ -322,13 +326,24 @@ export async function handleMessages(req, res) {
         if (forwardRt) {
             const ocCfg = (forwardRt.getConfig() ?? {});
             const agents = ocCfg.agents;
+            const agentEntry = agents?.list?.find((a) => agentIdFromSessionKey(`agent:${String(a?.id ?? "")}:x`) === targetAgentId);
+            const agentModel = agentEntry?.model;
+            const perAgentModel = typeof agentModel === "string"
+                ? agentModel
+                : typeof agentModel?.primary === "string"
+                    ? agentModel.primary
+                    : undefined;
+            const perAgentThinking = typeof agentEntry?.thinkingDefault === "string"
+                ? agentEntry.thinkingDefault
+                : undefined;
             const agentDefaults = agents?.defaults;
             const model = agentDefaults?.model;
-            defaultModel = typeof model?.primary === "string" ? model.primary : undefined;
-            defaultThinking =
-                typeof agentDefaults?.thinkingDefault === "string"
-                    ? agentDefaults.thinkingDefault
-                    : undefined;
+            const globalModel = typeof model?.primary === "string" ? model.primary : undefined;
+            const globalThinking = typeof agentDefaults?.thinkingDefault === "string"
+                ? agentDefaults.thinkingDefault
+                : undefined;
+            defaultModel = perAgentModel ?? globalModel;
+            defaultThinking = perAgentThinking ?? globalThinking;
         }
     }
     catch {

package/dist/src/http/server.js

@@ -14,6 +14,9 @@ import { handleNodesApprove } from "./handlers/nodes-approve.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
 import { handleAgentsList } from "./handlers/agents-list.js";
+import { handleHistorySessions } from "./handlers/history-sessions.js";
+import { handleHistoryMessages } from "./handlers/history-messages.js";
+import { handleHistorySetTitle } from "./handlers/history-set-title.js";
 import { handleStatus } from "./handlers/status.js";
 import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
@@ -68,6 +71,18 @@ async function handleFridayNextRoute(req, res) {
     if (req.method === "GET" && pathname === "/friday-next/status") {
         return await handleStatus(req, res);
     }
+    // Route: GET /friday-next/history/sessions (list all sessions across agents)
+    if (req.method === "GET" && pathname === "/friday-next/history/sessions") {
+        return await handleHistorySessions(req, res);
+    }
+    // Route: GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+    if (req.method === "GET" && pathname === "/friday-next/history/messages") {
+        return await handleHistoryMessages(req, res);
+    }
+    // Route: PUT /friday-next/sessions/title (sync app session name → server displayName)
+    if ((req.method === "PUT" || req.method === "POST") && pathname === "/friday-next/sessions/title") {
+        return await handleHistorySetTitle(req, res);
+    }
     // Route: GET /friday-next/health?deviceId=...&nodeDeviceId=...&selfHeal=true
     if (req.method === "GET" && pathname === "/friday-next/health") {
         return await handleHealth(req, res);

package/dist/src/session/session-manager.d.ts

@@ -3,6 +3,12 @@ export declare function splitModelRef(modelRef: string): {
     modelId: string;
 };
 export declare function toSessionStoreKey(rawSessionKey: string): string;
+/**
+ * Extract the agent id from a (possibly raw) session key. The downstream app now owns the
+ * full `agent:<id>:<rest>` key, so non-`main` agents must read/write their own session store
+ * directory. `agent:<id>:<rest>` → `<id>`; bare/legacy keys (or an unsafe id) → `main`.
+ */
+export declare function agentIdFromSessionKey(rawSessionKey: string): string;
 export declare function ensureSessionLevels(sessionKey: string, reasoningLevel: string, thinkingLevel: string, historyDir?: string): void;
 export interface FridaySessionSettings {
     reasoningLevel?: string;

package/dist/src/session/session-manager.js

@@ -3,6 +3,8 @@ import os from "node:os";
 import { readFileSync, writeFileSync } from "node:fs";
 const FRIDAY_AGENT_ID = "main";
 const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
+/** Path/shell-safe agent id (mirrors OpenClaw's `normalizeAgentId`). Anything else falls back to `main`. */
+const SAFE_AGENT_ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
 function deriveOpenClawBaseDir(historyDir) {
     if (historyDir) {
         const match = historyDir.replace(/[\\/]+$/, "").match(/(.*[\\/]\.openclaw)[\\/]/);
@@ -37,6 +39,16 @@ export function toSessionStoreKey(rawSessionKey) {
     }
     return `agent:${FRIDAY_AGENT_ID}:${lowered}`;
 }
+/**
+ * Extract the agent id from a (possibly raw) session key. The downstream app now owns the
+ * full `agent:<id>:<rest>` key, so non-`main` agents must read/write their own session store
+ * directory. `agent:<id>:<rest>` → `<id>`; bare/legacy keys (or an unsafe id) → `main`.
+ */
+export function agentIdFromSessionKey(rawSessionKey) {
+    const canonical = toSessionStoreKey(rawSessionKey);
+    const id = canonical.match(/^agent:([^:]+):/)?.[1];
+    return id && SAFE_AGENT_ID_RE.test(id) ? id : FRIDAY_AGENT_ID;
+}
 function toSafeSessionId(raw) {
     const s = raw.trim();
     if (SESSION_ID_RE.test(s))
@@ -54,8 +66,8 @@ function sessionIdForSessionsFile(fileKey, rawSessionKey) {
     for (const c of candidates) {
         if (SESSION_ID_RE.test(c))
             return c;
-        if (c.startsWith(`agent:${FRIDAY_AGENT_ID}:`)) {
-            const tail = c.slice(`agent:${FRIDAY_AGENT_ID}:`.length);
+        const tail = c.match(/^agent:[^:]+:(.+)$/)?.[1];
+        if (tail) {
             if (SESSION_ID_RE.test(tail))
                 return tail;
             return toSafeSessionId(tail);
@@ -63,9 +75,9 @@ function sessionIdForSessionsFile(fileKey, rawSessionKey) {
     }
     return toSafeSessionId(rawSessionKey || fileKey);
 }
-function resolveSessionsFilePath(historyDir) {
+function resolveSessionsFilePath(historyDir, agentId) {
     const base = deriveOpenClawBaseDir(historyDir);
-    return join(base, "agents/main/sessions/sessions.json");
+    return join(base, "agents", agentId, "sessions", "sessions.json");
 }
 function readSessionsData(path) {
     try {
@@ -98,11 +110,11 @@ export function ensureSessionLevels(sessionKey, reasoningLevel, thinkingLevel, h
 }
 export function setSessionSettings(sessionKey, settings, historyDir) {
     try {
-        const sessionsFile = resolveSessionsFilePath(historyDir);
+        const fileKey = toSessionStoreKey(sessionKey);
+        const sessionsFile = resolveSessionsFilePath(historyDir, agentIdFromSessionKey(fileKey));
         const data = readSessionsData(sessionsFile);
         if (!data)
             return {};
-        const fileKey = toSessionStoreKey(sessionKey);
         upsertSessionEntry(data, fileKey, sessionKey);
         const fieldKeys = [
             "reasoningLevel", "thinkingLevel", "modelRef", "providerOverride", "modelOverride",
@@ -137,11 +149,11 @@ function readSettingsFromEntry(entry) {
 }
 export function getSessionSettings(sessionKey, historyDir) {
     try {
-        const sessionsFile = resolveSessionsFilePath(historyDir);
+        const fileKey = toSessionStoreKey(sessionKey);
+        const sessionsFile = resolveSessionsFilePath(historyDir, agentIdFromSessionKey(fileKey));
         const data = readSessionsData(sessionsFile);
         if (!data)
             return {};
-        const fileKey = toSessionStoreKey(sessionKey);
         const entry = data[fileKey];
         if (!entry)
             return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",
@@ -12,15 +12,6 @@
     "tsconfig.json",
     "openclaw.plugin.json"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build",
-    "test": "npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
-    "test:e2e": "vitest run --config vitest.e2e.config.ts",
-    "test:smoke": "node scripts/e2e-smoke.mjs",
-    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
-  },
   "bin": {
     "friday-channel-next": "install.js"
   },
@@ -66,5 +57,13 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:smoke": "node scripts/e2e-smoke.mjs",
+    "test:msg-live": "node scripts/message-roundtrip-live.mjs"
   }
-}
+}

package/src/agent-forward-runtime.ts

@@ -6,6 +6,14 @@ export type FridayAgentForwardRuntime = {
     path: string,
     options?: { skipCache?: boolean; 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;
 };
 
@@ -16,6 +24,8 @@ export function setFridayAgentForwardRuntime(api: OpenClawPluginApi): void {
   forwardRuntime = {
     resolveStorePath: api.runtime.agent.session.resolveStorePath,
     loadSessionStore: api.runtime.agent.session.loadSessionStore,
+    updateSessionStoreEntry: (api.runtime.agent.session as Record<string, unknown>)
+      .updateSessionStoreEntry as FridayAgentForwardRuntime["updateSessionStoreEntry"],
     getConfig: () => api.runtime.config.current(),
   };
 }