@syengup/friday-channel-next 0.1.36 → 0.1.38

package/src/friday-session.forward-agent.test.ts

@@ -10,7 +10,10 @@ import {
   resetThinkingStreamAccumStateForTest,
 } from "./friday-session.js";
 import { resetRunMetadataForTest } from "./run-metadata.js";
-import { accumulateRunUsage, resetRunUsageAccumulatorForTest } from "./agent/run-usage-accumulator.js";
+import {
+  accumulateRunUsage,
+  resetRunUsageAccumulatorForTest,
+} from "./agent/run-usage-accumulator.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { toSessionStoreKey } from "./session/session-manager.js";
 
@@ -56,8 +59,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const first = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data.data;
-    const second = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data.data;
+    const first = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data
+      .data;
+    const second = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data
+      .data;
 
     expect(first.text).toBe(t1);
     expect(first.delta).toBe(t1);
@@ -94,7 +99,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(3);
-    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data.data;
+    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data
+      .data;
     expect(third.delta).toBe(t1);
     expect(third.reasoningPrefixChars).toBe(0);
   });
@@ -123,7 +129,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       data: { text: t1, delta: t1 },
     });
 
-    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data.data;
+    const third = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[2][1].data
+      .data;
     expect(third.reasoningPrefixChars).toBe(0);
     expect(third.delta).toBe(t1);
   });
@@ -179,7 +186,8 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     });
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(2);
-    const endPayload = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1].data;
+    const endPayload = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[1][1]
+      .data;
     expect(endPayload.stream).toBe("lifecycle");
     expect((endPayload.data as { phase?: string }).phase).toBe("end");
     expect(endPayload.sessionKey).toBe(sessionKey);
@@ -214,8 +222,18 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
       },
     } as never);
 
-    accumulateRunUsage(runId, { input: 100, output: 50, cacheRead: 10, total: 150 }, "my-model", "openai");
-    accumulateRunUsage(runId, { input: 30, output: 10, cacheRead: 0, total: 40 }, "my-model", "openai");
+    accumulateRunUsage(
+      runId,
+      { input: 100, output: 50, cacheRead: 10, total: 150 },
+      "my-model",
+      "openai",
+    );
+    accumulateRunUsage(
+      runId,
+      { input: 30, output: 10, cacheRead: 0, total: 40 },
+      "my-model",
+      "openai",
+    );
 
     forwardAgentEventRaw({
       runId,
@@ -232,7 +250,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     // llm_output fallback — per-run totals.
     expect(sessionUsage.modelId).toBe("my-model");
@@ -272,7 +293,12 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     } as never);
 
     // llm_output has fresher model/provider but per-run (smaller) tokens.
-    accumulateRunUsage(runId, { input: 500, output: 100, cacheRead: 200, total: 800 }, "llm-model", "llm-provider");
+    accumulateRunUsage(
+      runId,
+      { input: 500, output: 100, cacheRead: 200, total: 800 },
+      "llm-model",
+      "llm-provider",
+    );
 
     forwardAgentEventRaw({
       runId,
@@ -287,7 +313,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
 
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     // Store cumulative totals win.
     expect((sessionUsage.tokens as Record<string, unknown>).input).toBe(5000);
@@ -344,7 +373,10 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
     const forwarded = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls[0][1].data;
     expect(forwarded.stream).toBe("lifecycle");
-    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<string, unknown>;
+    const sessionUsage = (forwarded.data as Record<string, unknown>).sessionUsage as Record<
+      string,
+      unknown
+    >;
     expect(sessionUsage).toBeDefined();
     expect(sessionUsage.modelId).toBe("store-model");
     expect(sessionUsage.modelProvider).toBe("store-provider");

package/src/friday-session.ts

@@ -49,7 +49,7 @@ export function deviceIdFromSessionKey(sessionKey: string): string | null {
   const m1 = sessionKey.match(/^friday-next-(.+)$/i);
   if (m1) return m1[1] ?? null;
   const m2 = sessionKey.match(/^agent:main:friday-next-(.+)$/i);
-  return m2 ? m2[1] ?? null : null;
+  return m2 ? (m2[1] ?? null) : null;
 }
 
 /**
@@ -66,7 +66,8 @@ const deviceIdToLatestHistorySessionKey = new Map<string, string>();
 let lastRegisteredFridayDeviceId: string | undefined;
 
 function normalizeFridaySessionKeyCase(sk: string): string {
-  return /^friday-next-|^agent:main:friday-next-/i.test(sk) || /^agent:main:friday-next:direct:/i.test(sk)
+  return /^friday-next-|^agent:main:friday-next-/i.test(sk) ||
+    /^agent:main:friday-next:direct:/i.test(sk)
     ? sk.toLowerCase()
     : sk;
 }
@@ -157,7 +158,11 @@ function mergeRunMetadataIntoLifecycleEnd(
   if (typeof meta.modelName === "string" && meta.modelName.trim()) {
     extra.modelName = meta.modelName.trim();
   }
-  if (typeof meta.totalTokens === "number" && Number.isFinite(meta.totalTokens) && meta.totalTokens > 0) {
+  if (
+    typeof meta.totalTokens === "number" &&
+    Number.isFinite(meta.totalTokens) &&
+    meta.totalTokens > 0
+  ) {
     extra.totalTokens = Math.floor(meta.totalTokens);
   }
   if (
@@ -260,7 +265,10 @@ function completeAgentEventForward(params: {
 /**
  * Resolve the real device UUID for Friday outbound (`sendText` / `sendMedia`).
  */
-export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?: Record<string, unknown>): string {
+export function resolveFridayDeviceIdForOutbound(
+  to: string | undefined,
+  rawCtx?: Record<string, unknown>,
+): string {
   const trimmed = (to ?? "").trim();
   if (trimmed && trimmed.toLowerCase() !== "friday-next") {
     return trimmed;
@@ -279,6 +287,23 @@ export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?
   return trimmed || "friday-next";
 }
 
+/**
+ * Stringify a subagent error payload for the wire. `evt.data.error` comes from an
+ * in-process SDK callback, so it can be a real Error, a plain object, or a value
+ * that JSON.stringify would throw on (circular/BigInt) — keep this total and
+ * never-throwing, since it runs on the error path that emits `subagent ended`.
+ */
+function stringifySubagentError(raw: unknown): string {
+  if (raw == null) return "unknown";
+  if (typeof raw === "string") return raw;
+  if (raw instanceof Error) return raw.message || raw.name || "error";
+  try {
+    return JSON.stringify(raw) ?? "unknown";
+  } catch {
+    return "unstringifiable error";
+  }
+}
+
 /**
  * Forward global OpenClaw agent events to the Friday SSE connection (transparent).
  *
@@ -308,8 +333,7 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   if (!deviceIdRaw) return;
 
   if (!sk) {
-    sk =
-      latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
+    sk = latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
   }
 
   openClawRunIdToDeviceId.set(evt.runId, deviceIdRaw.toUpperCase());
@@ -325,11 +349,9 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   // Phase 1: spawning — tool.start with taskName in args
   if (isSpawnTool && evt.data.phase === "start") {
-    const toolCallId =
-      typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+    const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
     const args = evt.data.args as Record<string, unknown> | undefined;
-    const label =
-      typeof args?.taskName === "string" ? args.taskName : undefined;
+    const label = typeof args?.taskName === "string" ? args.taskName : undefined;
     if (toolCallId) {
       const intent = registerSpawnIntent({
         toolCallId,
@@ -362,15 +384,12 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
       | { childSessionKey?: string; runId?: string; taskName?: string }
       | undefined;
     if (details?.childSessionKey) {
-      const toolCallId =
-        typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+      const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
       const intent = toolCallId ? consumeSpawnIntent(toolCallId) : undefined;
       const label =
         details.taskName ||
         intent?.label ||
-        (typeof (evt.data as Record<string, unknown>).meta === "string"
-          ? ((evt.data as Record<string, unknown>).meta as string)
-          : undefined);
+        (typeof evt.data.meta === "string" ? evt.data.meta : undefined);
       const entry = ensureSubagentFromSpawnTool({
         childSessionKey: details.childSessionKey,
         bareRunId: details.runId,
@@ -404,10 +423,13 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   // Only annotate events that originate from the subagent itself
   // (sessionKey matches childSessionKey). Main-agent delivery events
   // share the announce runId but have a different sessionKey.
-  const isSubagentOwnEvent =
-    subagentEntry && sk && subagentEntry.childSessionKey === sk;
+  const isSubagentOwnEvent = subagentEntry && sk && subagentEntry.childSessionKey === sk;
   const subagentMeta = isSubagentOwnEvent
-    ? { label: subagentEntry.label, parentRunId: subagentEntry.parentRunId, depth: subagentEntry.depth }
+    ? {
+        label: subagentEntry.label,
+        parentRunId: subagentEntry.parentRunId,
+        depth: subagentEntry.depth,
+      }
     : undefined;
 
   let outgoingData: Record<string, unknown> = { ...evt.data };
@@ -436,12 +458,14 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   const lifecyclePhase =
     evt.stream === "lifecycle" && typeof evt.data.phase === "string" ? evt.data.phase : "";
-  const isTerminalLifecycle = evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
+  const isTerminalLifecycle =
+    evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
 
   // Emit subagent ended SSE when a subagent run terminates
   if (isTerminalLifecycle && isSubagentOwnEvent && subagentEntry.status !== "ended") {
     const outcome = lifecyclePhase === "error" ? "error" : "ok";
-    const errorStr = lifecyclePhase === "error" ? String(evt.data.error ?? "unknown") : undefined;
+    const errorStr =
+      lifecyclePhase === "error" ? stringifySubagentError(evt.data.error) : undefined;
     const ended = registerSubagentEnded({ runId: evt.runId, outcome, error: errorStr });
     if (ended) {
       sseEmitter.broadcast(

package/src/history/normalize-message.test.ts

@@ -1,8 +1,5 @@
 import { describe, it, expect } from "vitest";
-import {
-  normalizeHistoryMessage,
-  normalizeHistoryMessages,
-} from "./normalize-message.js";
+import { normalizeHistoryMessage, normalizeHistoryMessages } from "./normalize-message.js";
 
 function meta(id?: string, seq = 1, extra: Record<string, unknown> = {}) {
   return { __openclaw: { ...(id ? { id } : {}), seq, recordTimestampMs: 1700000000000, ...extra } };
@@ -124,7 +121,7 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toBeUndefined();
   });
 
-  it("keeps image blocks on non-canvas toolResults", () => {
+  it("keeps image blocks on image-producing (image_generation) toolResults", () => {
     const out = normalizeHistoryMessage(
       {
         role: "toolResult",
@@ -138,11 +135,34 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toEqual([{ mimeType: "image/png", data: "REALIMG" }]);
   });
 
+  it("drops inline image blocks on read toolResults (agent visual input, not an attachment)", () => {
+    // The `read` tool returns the file it fed to the model as an inline base64
+    // image so the agent can "see" it. That is NOT a user-facing attachment —
+    // surfacing it spawned phantom corrupt image bubbles on history rebuild for
+    // turns where the agent only LOOKED at a file and sent nothing.
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "tc-read",
+        toolName: "read",
+        content: [
+          { type: "text", text: "Read image file [image/jpeg]" },
+          { type: "image", mimeType: "image/jpeg", data: "AGENTVISUALINPUT" },
+        ],
+        ...meta("entry-read", 7),
+      },
+      0,
+    );
+    expect(out?.toolResult?.images).toBeUndefined();
+    expect(out?.toolResult?.text).toBe("Read image file [image/jpeg]");
+  });
+
   it("strips MEDIA: lines from text into mediaPaths", () => {
     const out = normalizeHistoryMessage(
       {
         role: "assistant",
-        content: "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
+        content:
+          "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
         ...meta("a1", 1),
       },
       0,
@@ -158,13 +178,20 @@ describe("normalizeHistoryMessage", () => {
     );
     expect(out?.text).toBe("two files");
     expect(out?.mediaPaths).toEqual(["/a/x.png", "/a/y.mp4"]);
-    const plain = normalizeHistoryMessage({ role: "user", content: "no media here", ...meta("u", 1) }, 0);
+    const plain = normalizeHistoryMessage(
+      { role: "user", content: "no media here", ...meta("u", 1) },
+      0,
+    );
     expect(plain?.mediaPaths).toBeUndefined();
   });
 
   it("flags compaction records via __openclaw.kind", () => {
     const out = normalizeHistoryMessage(
-      { role: "system", content: [{ type: "text", text: "Compaction" }], ...meta("c1", 9, { kind: "compaction" }) },
+      {
+        role: "system",
+        content: [{ type: "text", text: "Compaction" }],
+        ...meta("c1", 9, { kind: "compaction" }),
+      },
       0,
     );
     expect(out?.kind).toBe("compaction");

package/src/history/normalize-message.ts

@@ -104,6 +104,17 @@ function splitMediaLines(text: string): { text: string; paths: string[] } {
   return { text: cleaned, paths };
 }
 
+/**
+ * Tools whose `toolResult` carries a user-facing PRODUCED image, which stays a
+ * chat attachment. Every OTHER tool's inline image block is the agent's visual
+ * INPUT — a file the `read` tool fed to the model, a `canvas` snapshot, a
+ * browser screenshot — and must NOT surface as an attachment on history rebuild
+ * (it spawns phantom, often-corrupt bubbles for turns where the agent never
+ * sent a file). Keep this a whitelist so any new image-CONSUMING tool is safe by
+ * default; add new image-PRODUCING tools here explicitly.
+ */
+const IMAGE_PRODUCING_TOOLS = new Set(["image_generation"]);
+
 const MEDIA_MARKER_RE = /\[media attached:\s*([^\]]+)\]/gi;
 
 /** Pull `[media attached: <url>]` markers out of free text into image refs. */
@@ -219,10 +230,7 @@ function normalizeRole(raw: unknown): FridayHistoryRole {
  * 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: unknown,
-  index: number,
-): FridayHistoryMessage | null {
+export function normalizeHistoryMessage(raw: unknown, index: number): FridayHistoryMessage | null {
   const record = asRecord(raw);
   if (!record) return null;
 
@@ -254,14 +262,18 @@ export function normalizeHistoryMessage(
   if (role === "toolResult") {
     const split = splitMediaLines(parsed.text);
     const toolName = readString(record.toolName);
-    // Canvas snapshots come back as base64 image blocks on the `canvas` tool result so the *agent*
-    // can "see" the rendered page — they must never surface as chat attachments on history rebuild.
-    // The streaming deliver path already drops the temp-file form (see isCanvasSnapshotMediaPath in
-    // http/handlers/messages.ts); this is the transcript-rebuild counterpart. The canvas tool has no
-    // other image-returning action, so all images on a canvas result are snapshots.
-    const isCanvasResult = toolName === "canvas";
-    const images = isCanvasResult ? [] : parsed.images;
-    const mediaPaths = isCanvasResult ? [] : split.paths;
+    // Inline image blocks on a toolResult are almost always the agent's visual
+    // INPUT — a file the `read` tool fed to the model, a `canvas` snapshot (so the
+    // agent can "see" the rendered page), a browser screenshot — NOT a user-facing
+    // attachment. Surfacing them spawns phantom, often-corrupt attachment bubbles on
+    // history rebuild for turns where the agent never sent a file. Only tools that
+    // PRODUCE a user-facing image keep their blocks. (This was a `canvas`-only
+    // blacklist, which still leaked `read`/screenshot images.) The streaming deliver
+    // path drops the canvas temp-file form separately (isCanvasSnapshotMediaPath in
+    // http/handlers/messages.ts); this is the transcript-rebuild counterpart.
+    const keepInlineImages = toolName ? IMAGE_PRODUCING_TOOLS.has(toolName) : false;
+    const images = keepInlineImages ? parsed.images : [];
+    const mediaPaths = toolName === "canvas" ? [] : split.paths;
     const toolResult: FridayHistoryToolResult = {
       ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
       ...(toolName ? { toolName } : {}),

package/src/history/read-transcript.ts

@@ -40,10 +40,7 @@ function resolveEntry(store: Record<string, unknown>, sessionKey: string): unkno
   return undefined;
 }
 
-export function resolveTranscriptPath(
-  entry: unknown,
-  storePath: string,
-): string | undefined {
+export function resolveTranscriptPath(entry: unknown, storePath: string): string | undefined {
   const sessionFile = entryString(entry, "sessionFile");
   if (sessionFile) {
     return path.isAbsolute(sessionFile)

package/src/http/handlers/agent-config.test.ts

@@ -123,7 +123,9 @@ describe("handleAgentConfig", () => {
   });
 
   it("PUT sets the model on an existing entry", async () => {
-    const config: Record<string, unknown> = { agents: { list: [{ id: "main", model: "old/model" }] } };
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
     setRuntimes(config);
     const res = new MockRes();
     await handleAgentConfig(makeReq(AUTH, "PUT", { model: "openai/gpt-5" }), res as any, "main");
@@ -133,7 +135,9 @@ describe("handleAgentConfig", () => {
   });
 
   it("PUT model:null deletes the field so it inherits defaults", async () => {
-    const config: Record<string, unknown> = { agents: { list: [{ id: "main", model: "old/model" }] } };
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
     setRuntimes(config);
     const res = new MockRes();
     await handleAgentConfig(makeReq(AUTH, "PUT", { model: null }), res as any, "main");
@@ -197,7 +201,10 @@ describe("handleAgentConfig", () => {
       setRuntimes({ agents: { list: [{ id: "main" }] } }, workspace);
       const res = new MockRes();
       await handleAgentConfig(makeReq(AUTH), res as any, "main");
-      expect(JSON.parse(res.body).availableSkills.map((s: { id: string }) => s.id)).toEqual(["deep-research", "verify"]);
+      expect(JSON.parse(res.body).availableSkills.map((s: { id: string }) => s.id)).toEqual([
+        "deep-research",
+        "verify",
+      ]);
     } finally {
       fs.rmSync(workspace, { recursive: true, force: true });
     }

package/src/http/handlers/agent-config.ts

@@ -60,7 +60,9 @@ function readString(value: unknown): string | undefined {
 
 function readStringArray(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) return undefined;
-  const out = value.filter((v): v is string => typeof v === "string" && v.trim().length > 0).map((v) => v.trim());
+  const out = value
+    .filter((v): v is string => typeof v === "string" && v.trim().length > 0)
+    .map((v) => v.trim());
   return out;
 }
 
@@ -81,7 +83,9 @@ function readToolsConfig(value: unknown): AgentToolsConfig | undefined {
 
 /** Locate the configured `agents.list[]` entry whose normalized id matches `agentId`. */
 function findAgentEntry(cfg: unknown, agentId: string): Record<string, unknown> | undefined {
-  const agents = (cfg as Record<string, unknown> | undefined)?.agents as Record<string, unknown> | undefined;
+  const agents = (cfg as Record<string, unknown> | undefined)?.agents as
+    | Record<string, unknown>
+    | undefined;
   const list = agents?.list as Array<Record<string, unknown>> | undefined;
   if (!Array.isArray(list)) return undefined;
   return list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
@@ -108,7 +112,11 @@ function buildConfigView(agentId: string): AgentConfigView {
 /** A field present in the body: `undefined` = not sent (keep), `null` = clear, else new value. */
 type Patch<T> = { sent: boolean; clear: boolean; value?: T };
 
-function readPatch<T>(body: Record<string, unknown>, key: string, coerce: (raw: unknown) => T | undefined): Patch<T> {
+function readPatch<T>(
+  body: Record<string, unknown>,
+  key: string,
+  coerce: (raw: unknown) => T | undefined,
+): Patch<T> {
   if (!(key in body)) return { sent: false, clear: false };
   const raw = body[key];
   if (raw === null) return { sent: true, clear: true };
@@ -117,7 +125,7 @@ function readPatch<T>(body: Record<string, unknown>, key: string, coerce: (raw:
   return { sent: true, clear: false, value };
 }
 
-function coerceModel(raw: unknown): unknown | undefined {
+function coerceModel(raw: unknown): unknown {
   if (typeof raw === "string") return raw.trim() || undefined;
   if (raw && typeof raw === "object") {
     const primary = readString((raw as Record<string, unknown>).primary);
@@ -134,7 +142,7 @@ function coerceTools(raw: unknown): AgentToolsConfig | undefined {
 
 /** Skills: array (incl. empty = disable all) only; non-arrays are rejected upstream. */
 function coerceSkills(raw: unknown): string[] | undefined {
-  return Array.isArray(raw) ? readStringArray(raw) ?? [] : undefined;
+  return Array.isArray(raw) ? (readStringArray(raw) ?? []) : undefined;
 }
 
 // --- handler -----------------------------------------------------------------
@@ -167,10 +175,14 @@ export async function handleAgentConfig(
   const skills = readPatch(body, "skills", coerceSkills);
 
   if ("skills" in body && body.skills !== null && !Array.isArray(body.skills)) {
-    return json(res, 400, { error: "skills must be an array of skill ids, [] to disable all, or null to inherit defaults" });
+    return json(res, 400, {
+      error: "skills must be an array of skill ids, [] to disable all, or null to inherit defaults",
+    });
   }
   if (!model.sent && !thinkingDefault.sent && !tools.sent && !skills.sent) {
-    return json(res, 400, { error: "No editable fields provided (model, thinkingDefault, tools, skills)" });
+    return json(res, 400, {
+      error: "No editable fields provided (model, thinkingDefault, tools, skills)",
+    });
   }
 
   const upgrade = getUpgradeRuntime();
@@ -184,7 +196,9 @@ export async function handleAgentConfig(
         const draft = draftRaw as Record<string, unknown>;
         const agents = (draft.agents ??= {}) as Record<string, unknown>;
         const list = (agents.list ??= []) as Array<Record<string, unknown>>;
-        let entry = list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
+        let entry = list.find(
+          (a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId,
+        );
         if (!entry) {
           // Implicit agent (e.g. "main") with no list entry yet — create a bare one.
           // Never set `default: true`: that would change default-agent resolution.

package/src/http/handlers/agents-list.test.ts

@@ -141,11 +141,7 @@ describe("handleAgentsList", () => {
   it("defaults to the first entry when none is marked default and dedups ids", async () => {
     setConfig({
       agents: {
-        list: [
-          { id: "alpha" },
-          { id: "alpha", name: "dup" },
-          { id: "beta" },
-        ],
+        list: [{ id: "alpha" }, { id: "alpha", name: "dup" }, { id: "beta" }],
       },
     });
     const res = new MockRes();

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

@@ -19,8 +19,14 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, headers: Record<string, string> = {}): PassThrough & { method: string; headers: Record<string, string> } {
-  const stream = new PassThrough() as unknown as PassThrough & { method: string; headers: Record<string, string> };
+function mockReq(
+  method: string,
+  headers: Record<string, string> = {},
+): PassThrough & { method: string; headers: Record<string, string> } {
+  const stream = new PassThrough() as unknown as PassThrough & {
+    method: string;
+    headers: Record<string, string>;
+  };
   stream.method = method;
   stream.headers = headers;
   return stream;
@@ -63,7 +69,10 @@ describe("handleCancel", () => {
     req.end(JSON.stringify({ sessionKey: "sk-1" }));
     await p;
     expect((res as unknown as MockRes).statusCode).toBe(200);
-    expect(JSON.parse((res as unknown as MockRes).body)).toMatchObject({ ok: true, sessionKey: "sk-1" });
+    expect(JSON.parse((res as unknown as MockRes).body)).toMatchObject({
+      ok: true,
+      sessionKey: "sk-1",
+    });
   });
 
   it("untracks run by runId fallback under Vitest (abort skipped)", async () => {

package/src/http/handlers/cancel.ts

@@ -25,14 +25,16 @@ export async function handleCancel(req: IncomingMessage, res: ServerResponse): P
   // back-compat fallback for older apps — resolve it to a sessionKey via the run route.
   const sessionKey =
     (typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "") ||
-    (runId ? getRunRoute(runId)?.sessionKey?.trim() ?? "" : "");
+    (runId ? (getRunRoute(runId)?.sessionKey?.trim() ?? "") : "");
   if (!sessionKey && !runId) {
     res.statusCode = 400;
     res.setHeader("Content-Type", "application/json");
     res.end(JSON.stringify({ error: "Missing sessionKey or runId" }));
     return true;
   }
-  const result = sessionKey ? await abortRunForSessionKey(sessionKey) : { aborted: false, drained: false };
+  const result = sessionKey
+    ? await abortRunForSessionKey(sessionKey)
+    : { aborted: false, drained: false };
   if (runId) sseEmitter.untrackRun(runId);
   res.statusCode = 200;
   res.setHeader("Content-Type", "application/json");

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

@@ -28,8 +28,14 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, headers: Record<string, string> = {}): PassThrough & { method: string; headers: Record<string, string> } {
-  const stream = new PassThrough() as unknown as PassThrough & { method: string; headers: Record<string, string> };
+function mockReq(
+  method: string,
+  headers: Record<string, string> = {},
+): PassThrough & { method: string; headers: Record<string, string> } {
+  const stream = new PassThrough() as unknown as PassThrough & {
+    method: string;
+    headers: Record<string, string>;
+  };
   stream.method = method;
   stream.headers = headers;
   return stream;
@@ -92,7 +98,10 @@ describe("handleDeviceApprove", () => {
   });
 
   it("returns 404 when listDevicePairing returns data without matching device", async () => {
-    mockList.mockResolvedValueOnce({ pending: [{ requestId: "x", deviceId: "UNMATCHED" }], paired: [] });
+    mockList.mockResolvedValueOnce({
+      pending: [{ requestId: "x", deviceId: "UNMATCHED" }],
+      paired: [],
+    });
 
     const req = mockReq("POST", { authorization: "Bearer test-token" });
     const res = new MockRes() as unknown as ServerResponse;