@syengup/friday-channel-next 0.1.36 → 0.1.38

package/src/http/handlers/device-approve.ts

@@ -67,21 +67,25 @@ export async function handleDeviceApprove(
     if (pairedDevice) {
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        ok: true,
-        deviceId: normalizedDeviceId,
-        alreadyApproved: true,
-        approvedAtMs: (pairedDevice as any).approvedAtMs,
-      }));
+      res.end(
+        JSON.stringify({
+          ok: true,
+          deviceId: normalizedDeviceId,
+          alreadyApproved: true,
+          approvedAtMs: (pairedDevice as any).approvedAtMs,
+        }),
+      );
       return true;
     }
 
     res.statusCode = 404;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({
-      error: "No pending device found for this deviceId",
-      deviceId: normalizedDeviceId,
-    }));
+    res.end(
+      JSON.stringify({
+        error: "No pending device found for this deviceId",
+        deviceId: normalizedDeviceId,
+      }),
+    );
     return true;
   }
 
@@ -95,10 +99,12 @@ export async function handleDeviceApprove(
     log.error(`approveDevicePairing failed: ${err instanceof Error ? err.message : String(err)}`);
     res.statusCode = 502;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({
-      error: "Device approval failed",
-      detail: err instanceof Error ? err.message : "Unknown error",
-    }));
+    res.end(
+      JSON.stringify({
+        error: "Device approval failed",
+        detail: err instanceof Error ? err.message : "Unknown error",
+      }),
+    );
     return true;
   }
 
@@ -112,17 +118,23 @@ export async function handleDeviceApprove(
   if (approved.status === "forbidden") {
     res.statusCode = 403;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({ error: `Device approval forbidden: ${(approved as any).reason ?? "unknown"}` }));
+    res.end(
+      JSON.stringify({
+        error: `Device approval forbidden: ${(approved as any).reason ?? "unknown"}`,
+      }),
+    );
     return true;
   }
 
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({
-    ok: true,
-    deviceId: normalizedDeviceId,
-    requestId: approved.requestId,
-    approvedAtMs: (approved as any).device?.approvedAtMs,
-  }));
+  res.end(
+    JSON.stringify({
+      ok: true,
+      deviceId: normalizedDeviceId,
+      requestId: approved.requestId,
+      approvedAtMs: (approved as any).device?.approvedAtMs,
+    }),
+  );
   return true;
 }

package/src/http/handlers/files-download.ts

@@ -63,7 +63,10 @@ function tryDecodeURIComponent(segment: string): string | null {
  */
 function contentDispositionInline(filename: string): string {
   const base =
-    path.basename(filename).replace(/[\r\n"]/g, "_").replace(/\\/g, "_") || "file";
+    path
+      .basename(filename)
+      .replace(/[\r\n"]/g, "_")
+      .replace(/\\/g, "_") || "file";
   const ascii = /^[\x20-\x7E]*$/.test(base) ? base : "file";
   return `inline; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(base)}`;
 }
@@ -82,9 +85,7 @@ function sendBuffer(
   const disposition = contentDispositionInline(filename);
   const rangeRaw = req.headers.range;
   const range =
-    typeof rangeRaw === "string" && /^bytes=/i.test(rangeRaw.trim())
-      ? rangeRaw.trim()
-      : undefined;
+    typeof rangeRaw === "string" && /^bytes=/i.test(rangeRaw.trim()) ? rangeRaw.trim() : undefined;
 
   res.setHeader("Accept-Ranges", "bytes");
   res.setHeader("Cache-Control", "private, max-age=3600");
@@ -110,7 +111,7 @@ function sendBuffer(
   let end = total - 1;
 
   if (m[1] === "" && m[2] !== "") {
-    const suffixLen = parseInt(m[2]!, 10);
+    const suffixLen = parseInt(m[2], 10);
     if (!Number.isFinite(suffixLen) || suffixLen <= 0) {
       res.statusCode = 200;
       res.setHeader("Content-Length", String(total));
@@ -120,11 +121,11 @@ function sendBuffer(
     start = Math.max(0, total - suffixLen);
     end = total - 1;
   } else if (m[1] !== "" && m[2] === "") {
-    start = parseInt(m[1]!, 10);
+    start = parseInt(m[1], 10);
     end = total - 1;
   } else if (m[1] !== "" && m[2] !== "") {
-    start = parseInt(m[1]!, 10);
-    end = parseInt(m[2]!, 10);
+    start = parseInt(m[1], 10);
+    end = parseInt(m[2], 10);
   }
 
   if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= total) {
@@ -190,7 +191,13 @@ export async function handleFilesDownload(
     // 1.2 Plugin-root attachments/ (survives gateway restarts; basename = URL token)
     const fromAttachments = readAttachmentFileFromDisk(fileToken);
     if (fromAttachments) {
-      sendBuffer(req, res, fromAttachments.buffer, fromAttachments.mimeType, fromAttachments.filename);
+      sendBuffer(
+        req,
+        res,
+        fromAttachments.buffer,
+        fromAttachments.mimeType,
+        fromAttachments.filename,
+      );
       return true;
     }
 
@@ -211,10 +218,7 @@ export async function handleFilesDownload(
     // fileId may include an extension (e.g. "uuid.png") — strip it to get the base id
     const baseId = fileToken.replace(/\.[^.]+$/, "");
     const mediaDir = path.join(os.homedir(), ".openclaw", "media", "inbound");
-    const candidates = [
-      path.join(mediaDir, baseId),
-      path.join(mediaDir, fileToken),
-    ];
+    const candidates = [path.join(mediaDir, baseId), path.join(mediaDir, fileToken)];
 
     for (const filePath of candidates) {
       if (fs.existsSync(filePath)) {

package/src/http/handlers/files.test.ts

@@ -28,7 +28,11 @@ afterEach(() => {
 
 describe("attachment original filename survives a gateway restart", () => {
   it("stores under a uuid token but recovers the original filename from disk", () => {
-    const stored = storeFile(Buffer.from("%PDF-1.4 fake"), "Quarterly Report.pdf", "application/pdf");
+    const stored = storeFile(
+      Buffer.from("%PDF-1.4 fake"),
+      "Quarterly Report.pdf",
+      "application/pdf",
+    );
     expect(stored.urlToken).not.toBe("Quarterly Report.pdf");
 
     const disk = readAttachmentFileFromDisk(stored.urlToken);
@@ -57,7 +61,9 @@ describe("attachment original filename survives a gateway restart", () => {
     const stored = storeFile(Buffer.from("x"), "doc.docx", "application/octet-stream");
     clearFileIndexForTest();
 
-    const publicUrl = fridayFilesPublicUrl(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
+    const publicUrl = fridayFilesPublicUrl(
+      `/friday-next/files/${encodeURIComponent(stored.urlToken)}`,
+    );
     expect(publicUrl).toBe(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
   });
 

package/src/http/handlers/files.ts

@@ -25,7 +25,9 @@ export function setAttachmentsDirForTest(dir: string | null): void {
 /** Resolve `<historyDir>/../attachments`, mirroring the offline-queue layout. */
 function resolveAttachmentsDir(): string {
   try {
-    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    const cfg = resolveFridayNextConfig(
+      getHostOpenClawConfigSnapshot(getFridayNextRuntime().config),
+    );
     return path.join(path.dirname(cfg.historyDir), "attachments");
   } catch {
     return path.join(os.homedir(), ".openclaw", "friday-next", "attachments");
@@ -112,7 +114,11 @@ function writeAttachmentMetaSidecar(urlToken: string, filename: string, mimeType
  * is unrecoverable. We stash it here (keyed by the inbound basename, reusing the sidecar
  * scheme but inside our own attachments dir) at send time, while we still know it.
  */
-export function rememberInboundMediaName(inboundPath: string, filename: string, mimeType: string): void {
+export function rememberInboundMediaName(
+  inboundPath: string,
+  filename: string,
+  mimeType: string,
+): void {
   const key = path.basename(inboundPath);
   const name = filename.trim();
   if (!key || !name) return;
@@ -191,7 +197,10 @@ export function normalizeAgentMediaPath(raw: string): string {
   return s;
 }
 
-function copyLocalFileToAttachments(sourcePath: string, originalFilename?: string): StoredFile | null {
+function copyLocalFileToAttachments(
+  sourcePath: string,
+  originalFilename?: string,
+): StoredFile | null {
   const resolvedPath = normalizeAgentMediaPath(sourcePath);
   const diskBasename = path.basename(resolvedPath);
   // Prefer the caller-supplied original name (recovered from an inbound sidecar); fall
@@ -211,7 +220,9 @@ function copyLocalFileToAttachments(sourcePath: string, originalFilename?: strin
       // Fallback to read+write so attachment persistence still works.
       const raw = fs.readFileSync(resolvedPath);
       fs.writeFileSync(storedPath, raw);
-      logger.warn(`copyLocalFileToAttachments copy fallback used for "${resolvedPath}": ${String(copyErr)}`);
+      logger.warn(
+        `copyLocalFileToAttachments copy fallback used for "${resolvedPath}": ${String(copyErr)}`,
+      );
     }
     const stat = fs.statSync(storedPath);
     const mimeType = guessMimeType(filename);
@@ -246,7 +257,7 @@ export function storeFile(buffer: Buffer, filename: string, mimeType: string): S
   try {
     fs.writeFileSync(storedPath, buffer);
   } catch (err) {
-    throw new Error(`Failed to store file: ${String(err)}`);
+    throw new Error(`Failed to store file: ${String(err)}`, { cause: err });
   }
 
   const file: StoredFile = {
@@ -314,7 +325,11 @@ export function getExternalFileSourceByUrlToken(token: string): string | undefin
 /**
  * Read a file as a Buffer with its MIME type (by id or urlToken).
  */
-export function readFile(id: string): { buffer: Buffer | null; mimeType: string; filename?: string } {
+export function readFile(id: string): {
+  buffer: Buffer | null;
+  mimeType: string;
+  filename?: string;
+} {
   const file = resolveStoredFile(id);
   if (!file) return { buffer: null, mimeType: "application/octet-stream" };
   try {
@@ -400,7 +415,6 @@ export function resolveMediaAttachment(localPath: string): ResolvedAttachment |
   };
 }
 
-
 /**
  * Guess MIME type from filename extension.
  */

package/src/http/handlers/health.test.ts

@@ -23,7 +23,11 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, url: string, headers: Record<string, string> = {}): IncomingMessage {
+function mockReq(
+  method: string,
+  url: string,
+  headers: Record<string, string> = {},
+): IncomingMessage {
   return { method, url, headers } as IncomingMessage;
 }
 
@@ -82,7 +86,17 @@ describe("handleHealth", () => {
         {
           nodeId: NODE_ID,
           caps: ["location", "canvas"],
-          commands: ["location.get", "canvas.present", "canvas.hide", "canvas.navigate", "canvas.eval", "canvas.snapshot", "canvas.a2ui.push", "canvas.a2ui.pushJSONL", "canvas.a2ui.reset"],
+          commands: [
+            "location.get",
+            "canvas.present",
+            "canvas.hide",
+            "canvas.navigate",
+            "canvas.eval",
+            "canvas.snapshot",
+            "canvas.a2ui.push",
+            "canvas.a2ui.pushJSONL",
+            "canvas.a2ui.reset",
+          ],
         },
       ],
     });
@@ -104,9 +118,7 @@ describe("handleHealth", () => {
   it("returns degraded when node is missing required caps", async () => {
     mockListNodePairing.mockResolvedValueOnce({
       pending: [],
-      paired: [
-        { nodeId: NODE_ID, caps: ["canvas"], commands: ["canvas.present"] },
-      ],
+      paired: [{ nodeId: NODE_ID, caps: ["canvas"], commands: ["canvas.present"] }],
     });
 
     const req = mockReq("GET", `/friday-next/health?nodeDeviceId=${NODE_ID}`, {
@@ -127,7 +139,10 @@ describe("handleHealth", () => {
       pending: [{ requestId: REQUEST_ID, nodeId: NODE_ID }],
       paired: [],
     });
-    mockApproveNodePairing.mockResolvedValueOnce({ requestId: REQUEST_ID, node: { nodeId: NODE_ID } });
+    mockApproveNodePairing.mockResolvedValueOnce({
+      requestId: REQUEST_ID,
+      node: { nodeId: NODE_ID },
+    });
 
     const req = mockReq("GET", `/friday-next/health?nodeDeviceId=${NODE_ID}&selfHeal=true`, {
       authorization: "Bearer test-token",
@@ -186,7 +201,10 @@ describe("handleHealth", () => {
       pending: [{ requestId: REQUEST_ID, nodeId: NODE_ID }],
       paired: [],
     });
-    mockApproveNodePairing.mockResolvedValueOnce({ status: "forbidden", missingScope: "operator.admin" });
+    mockApproveNodePairing.mockResolvedValueOnce({
+      status: "forbidden",
+      missingScope: "operator.admin",
+    });
 
     const req = mockReq("GET", `/friday-next/health?nodeDeviceId=${NODE_ID}&selfHeal=true`, {
       authorization: "Bearer test-token",
@@ -236,14 +254,28 @@ describe("handleHealth", () => {
         {
           nodeId: NODE_ID,
           caps: ["location", "canvas"],
-          commands: ["location.get", "canvas.present", "canvas.hide", "canvas.navigate", "canvas.eval", "canvas.snapshot", "canvas.a2ui.push", "canvas.a2ui.pushJSONL", "canvas.a2ui.reset"],
+          commands: [
+            "location.get",
+            "canvas.present",
+            "canvas.hide",
+            "canvas.navigate",
+            "canvas.eval",
+            "canvas.snapshot",
+            "canvas.a2ui.push",
+            "canvas.a2ui.pushJSONL",
+            "canvas.a2ui.reset",
+          ],
         },
       ],
     });
 
-    const req = mockReq("GET", `/friday-next/health?deviceId=${DEVICE_ID}&nodeDeviceId=${NODE_ID}`, {
-      authorization: "Bearer test-token",
-    });
+    const req = mockReq(
+      "GET",
+      `/friday-next/health?deviceId=${DEVICE_ID}&nodeDeviceId=${NODE_ID}`,
+      {
+        authorization: "Bearer test-token",
+      },
+    );
     const res = new MockRes() as unknown as ServerResponse;
     await handleHealth(req, res);
     const body = JSON.parse((res as unknown as MockRes).body);

package/src/http/handlers/health.ts

@@ -75,7 +75,10 @@ export async function handleHealth(req: IncomingMessage, res: ServerResponse): P
     result.nodePairing = await checkNodePairing(nodeDeviceId, selfHeal, result, log);
   }
 
-  result.ok = !result.nodePairing || (result.nodePairing.status === "ok" || result.nodePairing.status === "pending");
+  result.ok =
+    !result.nodePairing ||
+    result.nodePairing.status === "ok" ||
+    result.nodePairing.status === "pending";
 
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");
@@ -113,7 +116,8 @@ async function checkNodePairing(
     };
   }
 
-  const pairedNodes: Array<{ nodeId: string; caps?: string[]; commands?: string[] }> = listData?.paired ?? [];
+  const pairedNodes: Array<{ nodeId: string; caps?: string[]; commands?: string[] }> =
+    listData?.paired ?? [];
   const pairedMatch = pairedNodes.find(
     (entry) => entry.nodeId?.trim().toUpperCase() === normalizedNodeId,
   );
@@ -156,16 +160,24 @@ async function checkNodePairing(
 
   if (pendingMatch && selfHeal) {
     try {
-      const callerScopes = ["operator.admin", "operator.pairing", "operator.read", "operator.write"];
+      const callerScopes = [
+        "operator.admin",
+        "operator.pairing",
+        "operator.read",
+        "operator.write",
+      ];
       const approved = await approveNodePairing(pendingMatch.requestId, { callerScopes });
-      const succeeded = approved != null && !("status" in approved && (approved as any).status === "forbidden") && "requestId" in approved;
+      const succeeded =
+        approved != null &&
+        !("status" in approved && approved.status === "forbidden") &&
+        "requestId" in approved;
       (result.repairActions ??= []).push({
         component: "nodePairing",
         action: "approveNodePairing",
         result: succeeded ? "ok" : "failed",
         detail: succeeded
           ? `Auto-approved node ${normalizedNodeId}`
-          : `approveNodePairing returned status=${(approved as any)?.status ?? "null"}`,
+          : `approveNodePairing returned status=${approved?.status ?? "null"}`,
       });
       if (succeeded) {
         log.info(`Auto-approved node ${normalizedNodeId}`);
@@ -191,5 +203,9 @@ async function checkNodePairing(
     return { status: "pending", detail: "Node is pending approval", nodePaired: false };
   }
 
-  return { status: "not_found", detail: `Node ${normalizedNodeId} not registered`, nodePaired: false };
+  return {
+    status: "not_found",
+    detail: `Node ${normalizedNodeId} not registered`,
+    nodePaired: false,
+  };
 }

package/src/http/handlers/history-messages.test.ts

@@ -35,7 +35,12 @@ const CFG = {
 let tmpDir = "";
 
 /** Auth config + optional subagent fallback. */
-function setRuntime(getSessionMessages?: (params: { sessionKey: string; limit?: number }) => Promise<{ messages?: unknown[] }>): void {
+function setRuntime(
+  getSessionMessages?: (params: {
+    sessionKey: string;
+    limit?: number;
+  }) => Promise<{ messages?: unknown[] }>,
+): void {
   setFridayNextRuntime({
     config: { loadConfig: () => CFG },
     logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
@@ -100,13 +105,30 @@ describe("handleHistoryMessages", () => {
   it("reads the transcript file from disk including user + assistant messages", async () => {
     const file = writeTranscript("sess.jsonl", [
       { type: "session", version: 1, sessionId: "s" },
-      { type: "message", id: "u1", timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: "hi there" } },
-      { type: "message", id: "a1", timestamp: "2026-01-01T00:00:01.000Z", message: { role: "assistant", content: [{ type: "text", text: "hello" }], model: "openai/gpt-4" } },
+      {
+        type: "message",
+        id: "u1",
+        timestamp: "2026-01-01T00:00:00.000Z",
+        message: { role: "user", content: "hi there" },
+      },
+      {
+        type: "message",
+        id: "a1",
+        timestamp: "2026-01-01T00:00:01.000Z",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "hello" }],
+          model: "openai/gpt-4",
+        },
+      },
     ]);
     setForward({ "agent:main:main": { sessionId: "s", sessionFile: file } });
 
     const res = new MockRes();
-    await handleHistoryMessages(makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH), res as any);
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH),
+      res as any,
+    );
     expect(res.statusCode).toBe(200);
     const body = JSON.parse(res.body);
     expect(body.messages.map((m: any) => m.role)).toEqual(["user", "assistant"]);
@@ -117,7 +139,15 @@ describe("handleHistoryMessages", () => {
   it("returns the cumulative sessionUsage snapshot from the store", async () => {
     const file = writeTranscript("usage.jsonl", [
       { type: "message", id: "u1", message: { role: "user", content: "hi" } },
-      { type: "message", id: "a1", message: { role: "assistant", content: [{ type: "text", text: "yo" }], model: "openai/gpt-4" } },
+      {
+        type: "message",
+        id: "a1",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "yo" }],
+          model: "openai/gpt-4",
+        },
+      },
     ]);
     setForward({
       "agent:main:main": {
@@ -132,7 +162,10 @@ describe("handleHistoryMessages", () => {
     });
 
     const res = new MockRes();
-    await handleHistoryMessages(makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH), res as any);
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH),
+      res as any,
+    );
     expect(res.statusCode).toBe(200);
     const body = JSON.parse(res.body);
     expect(body.sessionUsage).toBeDefined();
@@ -148,7 +181,10 @@ describe("handleHistoryMessages", () => {
     setForward({ "agent:main:main": { sessionId: "s", sessionFile: file } });
 
     const res = new MockRes();
-    await handleHistoryMessages(makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH), res as any);
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH),
+      res as any,
+    );
     const body = JSON.parse(res.body);
     expect(body.sessionUsage).toBeUndefined();
   });
@@ -162,7 +198,10 @@ describe("handleHistoryMessages", () => {
 
     const res = new MockRes();
     await handleHistoryMessages(
-      makeReq("/friday-next/history/messages?sessionKey=agent:main:friday:direct:ABCD-1234:9", AUTH),
+      makeReq(
+        "/friday-next/history/messages?sessionKey=agent:main:friday:direct:ABCD-1234:9",
+        AUTH,
+      ),
       res as any,
     );
     const body = JSON.parse(res.body);
@@ -209,7 +248,10 @@ describe("handleHistoryMessages", () => {
       messages: [{ role: "assistant", content: "fallback", __openclaw: { id: "a1", seq: 1 } }],
     }));
     const res = new MockRes();
-    await handleHistoryMessages(makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH), res as any);
+    await handleHistoryMessages(
+      makeReq("/friday-next/history/messages?sessionKey=agent:main:main", AUTH),
+      res as any,
+    );
     const body = JSON.parse(res.body);
     expect(body.messages.map((m: any) => m.id)).toEqual(["a1"]);
   });

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

@@ -15,7 +15,10 @@ import { fileURLToPath } from "node:url";
 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 {
+  readSessionTranscriptRawMessages,
+  resolveSessionId,
+} from "../../history/read-transcript.js";
 import { resolveMediaAttachment } from "./files.js";
 import { readSessionUsageSnapshotFromStore } from "../../session-usage-store.js";
 

package/src/http/handlers/history-sessions.test.ts

@@ -33,7 +33,11 @@ let tmpDir = "";
 /** Write a non-empty transcript file and return its absolute path. */
 function transcript(name: string): string {
   const file = path.join(tmpDir, name);
-  fs.writeFileSync(file, `${JSON.stringify({ type: "message", id: "m", message: { role: "user", content: "hi" } })}\n`, "utf-8");
+  fs.writeFileSync(
+    file,
+    `${JSON.stringify({ type: "message", id: "m", message: { role: "user", content: "hi" } })}\n`,
+    "utf-8",
+  );
   return file;
 }
 
@@ -86,7 +90,11 @@ describe("handleHistorySessions", () => {
       { agents: { list: [{ id: "main" }] } },
       {
         main: {
-          "agent:main:main": { sessionId: "s-main", updatedAt: 100, sessionFile: transcript("main.jsonl") },
+          "agent:main:main": {
+            sessionId: "s-main",
+            updatedAt: 100,
+            sessionFile: transcript("main.jsonl"),
+          },
           "agent:main:friday:direct:dev:1": {
             sessionId: "s-fd",
             updatedAt: 300,
@@ -112,8 +120,16 @@ describe("handleHistorySessions", () => {
       { agents: { list: [{ id: "main" }] } },
       {
         main: {
-          "agent:main:live": { sessionId: "a", updatedAt: 1, sessionFile: transcript("live.jsonl") },
-          "agent:main:archived": { sessionId: "b", updatedAt: 2, sessionFile: path.join(tmpDir, "gone.jsonl") },
+          "agent:main:live": {
+            sessionId: "a",
+            updatedAt: 1,
+            sessionFile: transcript("live.jsonl"),
+          },
+          "agent:main:archived": {
+            sessionId: "b",
+            updatedAt: 2,
+            sessionFile: path.join(tmpDir, "gone.jsonl"),
+          },
         },
       },
     );
@@ -129,11 +145,32 @@ describe("handleHistorySessions", () => {
       {
         main: {
           "agent:main:main": { sessionId: "ok", updatedAt: 5, sessionFile: transcript("ok.jsonl") },
-          "agent:main:main:heartbeat": { sessionId: "hb", updatedAt: 4, sessionFile: transcript("hb.jsonl") },
-          "agent:main:cron:abc": { sessionId: "c", updatedAt: 3, sessionFile: transcript("c.jsonl") },
-          "agent:main:subagent:xyz": { sessionId: "sa", updatedAt: 2, sessionFile: transcript("sa.jsonl") },
-          "agent:main:dreaming-narrative-rem-1": { sessionId: "d", updatedAt: 1, sessionFile: transcript("d.jsonl") },
-          "agent:main:child": { sessionId: "ch", updatedAt: 6, spawnedBy: "agent:main:main", sessionFile: transcript("ch.jsonl") },
+          "agent:main:main:heartbeat": {
+            sessionId: "hb",
+            updatedAt: 4,
+            sessionFile: transcript("hb.jsonl"),
+          },
+          "agent:main:cron:abc": {
+            sessionId: "c",
+            updatedAt: 3,
+            sessionFile: transcript("c.jsonl"),
+          },
+          "agent:main:subagent:xyz": {
+            sessionId: "sa",
+            updatedAt: 2,
+            sessionFile: transcript("sa.jsonl"),
+          },
+          "agent:main:dreaming-narrative-rem-1": {
+            sessionId: "d",
+            updatedAt: 1,
+            sessionFile: transcript("d.jsonl"),
+          },
+          "agent:main:child": {
+            sessionId: "ch",
+            updatedAt: 6,
+            spawnedBy: "agent:main:main",
+            sessionFile: transcript("ch.jsonl"),
+          },
           global: { sessionId: "g", updatedAt: 7, sessionFile: transcript("g.jsonl") },
         },
       },

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

@@ -139,12 +139,14 @@ function readAgentSessions(agentId: string): FridayHistorySessionSummary[] {
       sessionKey: canonicalKey,
       agentId,
       ...(readString(entry.sessionId) ? { sessionId: readString(entry.sessionId) } : {}),
-      ...(readNumber(entry.updatedAt) !== undefined ? { updatedAt: readNumber(entry.updatedAt) } : {}),
-      ...(readString(entry.model) ?? readString(entry.modelOverride)
+      ...(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)
+      ...((readString(entry.displayName) ?? readString(entry.label))
         ? { title: readString(entry.displayName) ?? readString(entry.label) }
         : {}),
     });