@selesai/code 0.5.28 → 0.5.29

package/dist/extensions/pi-intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-intercom",
-  "version": "0.6.0",
+  "version": "0.9.2",
   "license": "MIT",
   "type": "module",
   "main": "index.ts",
@@ -8,13 +8,16 @@
     "index.ts",
     "types.ts",
     "config.ts",
+    "cwd.ts",
+    "extension-api.ts",
+    "format-context.ts",
     "reply-tracker.ts",
     "broker/**/*.ts",
     "ui/**/*.ts",
     "skills/**/*"
   ],
   "scripts": {
-    "test": "tsx --test broker/paths.test.ts broker/spawn.test.ts reply-tracker.test.ts intercom.integration.test.ts test/inline-message.test.ts"
+    "test": "tsx --test broker/client.test.ts broker/extension.test.ts broker/framing.test.ts broker/paths.test.ts broker/runtime-claim.test.ts broker/spawn.test.ts config.test.ts cwd.test.ts format-context.test.ts reply-tracker.test.ts intercom.integration.test.ts test/inline-message.test.ts test/overlay-width.test.ts"
   },
   "keywords": [
     "pi-package"
@@ -28,11 +31,18 @@
     ]
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@selesai/code": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "dependencies": {
-    "tsx": "^4.20.0",
-    "typebox": "^1.1.24"
+    "tsx": "^4.20.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@selesai/code": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   }
 }

package/dist/extensions/pi-intercom/reply-tracker.test.ts

@@ -0,0 +1,134 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getAskTimeoutMs } from "./config.ts";
+import { ReplyTracker } from "./reply-tracker.ts";
+import type { Message, SessionInfo } from "./types.ts";
+
+function createSession(id: string, name: string): SessionInfo {
+  return {
+    id,
+    name,
+    cwd: "/tmp/project",
+    model: "test-model",
+    pid: 1,
+    startedAt: 1,
+    lastActivity: 1,
+  };
+}
+
+function createMessage(id: string, text: string, expectsReply = true): Message {
+  return {
+    id,
+    timestamp: 1,
+    expectsReply,
+    content: { text },
+  };
+}
+
+test("reply resolves from current triggered message context", () => {
+  const tracker = new ReplyTracker();
+  const from = createSession("planner-id", "planner");
+  const message = createMessage("ask-1", "Need a decision");
+
+  const context = tracker.recordIncomingMessage(from, message, 1000);
+  tracker.queueTurnContext(context);
+  tracker.beginTurn(1001);
+
+  assert.equal(tracker.resolveReplyTarget({}, 1002).message.id, "ask-1");
+  assert.equal(tracker.resolveReplyTarget({}, 1002).from.id, "planner-id");
+});
+
+test("reply resolves from single pending ask without current turn context", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a decision"), 1000);
+
+  assert.equal(tracker.resolveReplyTarget({}, 1001).message.id, "ask-1");
+});
+
+test("reply with to resolves matching pending ask", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);
+  tracker.recordIncomingMessage(createSession("reviewer-id", "reviewer"), createMessage("ask-2", "Second"), 1001);
+
+  assert.equal(tracker.resolveReplyTarget({ to: "reviewer" }, 1002).message.id, "ask-2");
+  assert.equal(tracker.resolveReplyTarget({ to: "planner-id" }, 1002).message.id, "ask-1");
+});
+
+test("explicit to overrides the current turn context", () => {
+  const tracker = new ReplyTracker();
+  const current = tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);
+  tracker.recordIncomingMessage(createSession("reviewer-id", "reviewer"), createMessage("ask-2", "Second"), 1001);
+  tracker.queueTurnContext(current);
+  tracker.beginTurn(1002);
+
+  assert.equal(tracker.resolveReplyTarget({ to: "reviewer" }, 1003).message.id, "ask-2");
+  assert.throws(() => tracker.resolveReplyTarget({ to: "missing" }, 1003), /No pending ask from/);
+});
+
+test("replyTo resolves the exact pending ask", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);
+  tracker.recordIncomingMessage(createSession("reviewer-id", "reviewer"), createMessage("ask-2", "Second"), 1001);
+
+  assert.equal(tracker.resolveReplyTarget({ replyTo: "ask-2" }, 1002).from.id, "reviewer-id");
+  assert.throws(() => tracker.resolveReplyTarget({ to: "planner", replyTo: "ask-2" }, 1002), /is not from/);
+});
+
+test("reply errors when no context and no pending asks", () => {
+  const tracker = new ReplyTracker();
+
+  assert.throws(() => tracker.resolveReplyTarget({}, 1000), /No active intercom context to reply to/);
+});
+
+test("reply errors when multiple pending asks and no to", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);
+  tracker.recordIncomingMessage(createSession("reviewer-id", "reviewer"), createMessage("ask-2", "Second"), 1001);
+
+  assert.throws(() => tracker.resolveReplyTarget({}, 1002), /Multiple pending asks — specify `to`/);
+});
+
+test("reply removes pending ask after successful reply", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a decision"), 1000);
+
+  tracker.markReplied("ask-1");
+
+  assert.deepEqual(tracker.listPending(1001), []);
+});
+
+test("ask timeout can be configured from environment", () => {
+  const previous = process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
+  process.env.PI_INTERCOM_ASK_TIMEOUT_MS = "42";
+  try {
+    assert.equal(getAskTimeoutMs(), 42);
+    assert.throws(() => {
+      process.env.PI_INTERCOM_ASK_TIMEOUT_MS = "0";
+      getAskTimeoutMs();
+    }, /positive integer/);
+  } finally {
+    if (previous === undefined) delete process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
+    else process.env.PI_INTERCOM_ASK_TIMEOUT_MS = previous;
+  }
+});
+
+test("pending asks can be explicitly dismissed without removing retryable failures", () => {
+  const tracker = new ReplyTracker();
+  tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a decision"), 1000);
+  tracker.recordIncomingMessage(createSession("reviewer-id", "reviewer"), createMessage("ask-2", "Retryable"), 1001);
+
+  tracker.dismissPendingAsk("ask-1");
+
+  assert.deepEqual(tracker.listPending(1002).map((context) => context.message.id), ["ask-2"]);
+});
+
+test("dismissing a pending ask removes queued turn context", () => {
+  const tracker = new ReplyTracker();
+  const context = tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a decision"), 1000);
+  tracker.queueTurnContext(context);
+
+  tracker.dismissPendingAsk("ask-1");
+  tracker.beginTurn(1001);
+
+  assert.throws(() => tracker.resolveReplyTarget({}, 1002), /No active intercom context to reply to/);
+});

package/dist/extensions/pi-intercom/reply-tracker.ts

@@ -1,3 +1,4 @@
+import { getAskTimeoutMs } from "./config.ts";
 import type { Message, SessionInfo } from "./types.ts";
 
 export interface IntercomContext {
@@ -19,7 +20,7 @@ export class ReplyTracker {
   private readonly pendingTurnContexts: IntercomContext[] = [];
   private currentTurnContext: IntercomContext | null = null;
 
-  constructor(private readonly askTimeoutMs = 10 * 60 * 1000) {}
+  constructor(private readonly askTimeoutMs = getAskTimeoutMs()) {}
 
   recordIncomingMessage(from: SessionInfo, message: Message, receivedAt = Date.now()): IntercomContext {
     const context = { from, message, receivedAt };
@@ -48,31 +49,39 @@ export class ReplyTracker {
     this.currentTurnContext = null;
   }
 
-  resolveReplyTarget(options: { to?: string }, now = Date.now()): IntercomContext {
+  resolveReplyTarget(options: { to?: string; replyTo?: string }, now = Date.now()): IntercomContext {
     this.pruneExpired(now);
 
-    if (this.currentTurnContext) {
-      return this.currentTurnContext;
+    if (options.replyTo) {
+      const target = this.pendingAsks.get(options.replyTo);
+      if (!target) {
+        throw new Error(`No pending ask with message ID "${options.replyTo}"`);
+      }
+      if (options.to && !matchesPendingSender(target, options.to)) {
+        throw new Error(`Pending ask "${options.replyTo}" is not from "${options.to}"`);
+      }
+      return target;
     }
 
     const pending = Array.from(this.pendingAsks.values());
-    if (pending.length === 1) {
-      return pending[0]!;
-    }
-
     if (options.to) {
       const matches = pending.filter((context) => matchesPendingSender(context, options.to!));
       if (matches.length === 1) {
         return matches[0]!;
       }
       if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from \"${options.to}\" — use the sender session ID instead.`);
-      }
-      if (pending.length > 1) {
-        throw new Error(`No pending ask from \"${options.to}\"`);
+        throw new Error(`Multiple pending asks from "${options.to}" — use the sender session ID instead.`);
       }
+      throw new Error(`No pending ask from "${options.to}"`);
+    }
+
+    if (this.currentTurnContext) {
+      return this.currentTurnContext;
     }
 
+    if (pending.length === 1) {
+      return pending[0]!;
+    }
     if (pending.length === 0) {
       throw new Error("No active intercom context to reply to");
     }
@@ -81,7 +90,16 @@ export class ReplyTracker {
   }
 
   markReplied(replyTo: string): void {
+    this.dismissPendingAsk(replyTo);
+  }
+
+  dismissPendingAsk(replyTo: string): void {
     this.pendingAsks.delete(replyTo);
+    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
+      if (this.pendingTurnContexts[index]?.message.id === replyTo) {
+        this.pendingTurnContexts.splice(index, 1);
+      }
+    }
     if (this.currentTurnContext?.message.id === replyTo) {
       this.currentTurnContext = null;
     }
@@ -95,7 +113,7 @@ export class ReplyTracker {
   private pruneExpired(now: number): void {
     for (const [messageId, context] of this.pendingAsks) {
       if (now - context.receivedAt > this.askTimeoutMs) {
-        this.pendingAsks.delete(messageId);
+        this.dismissPendingAsk(messageId);
       }
     }
   }

package/dist/extensions/pi-intercom/skills/pi-intercom/SKILL.md

@@ -2,15 +2,15 @@
 name: pi-intercom
 description: |
   Streamline session-to-session coordination with pi-intercom. Send messages,
-  delegate tasks, and coordinate work across multiple pi sessions on the same
+  delegate tasks, and coordinate work across multiple Selesai sessions on the same
   machine. Use for planner-worker workflows, cross-session context sharing,
   and real-time collaboration between sessions.
 ---
 
-# Pi Intercom Skill
+# Selesai Intercom Skill
 
-Use this skill when you need to coordinate work across multiple pi sessions
-running on the same machine. Pi-intercom enables direct 1:1 messaging between
+Use this skill when you need to coordinate work across multiple Selesai sessions
+running on the same machine. pi-intercom enables direct 1:1 messaging between
 sessions for delegation, context sharing, and collaborative workflows.
 
 When you are supervising `pi-subagents`, delegated child agents can escalate to
@@ -156,8 +156,8 @@ This works because `reply` resolves the correct sender and message ID automatica
 
 | Type | What it means | How to respond |
 |------|---------------|----------------|
-| `need_decision` | Subagent is blocked and waiting for your answer. Has a 10-minute timeout. | Reply promptly with a clear decision. If you need more context, ask follow-up questions via `reply`. |
-| `interview_request` | Subagent needs multiple structured answers in one blocking exchange. Has a 10-minute timeout. | Reply with plain JSON or a fenced `json` block using the provided `{ "responses": [...] }` shape. |
+| `need_decision` | Subagent is blocked and waiting for your answer. Uses the shared ask timeout: 10 minutes by default, configurable with `PI_INTERCOM_ASK_TIMEOUT_MS`. | Reply promptly with a clear decision. If you need more context, ask follow-up questions via `reply`. |
+| `interview_request` | Subagent needs multiple structured answers in one blocking exchange. Uses the shared ask timeout: 10 minutes by default, configurable with `PI_INTERCOM_ASK_TIMEOUT_MS`. | Reply with plain JSON or a fenced `json` block using the provided `{ "responses": [...] }` shape. |
 | `progress_update` | Subagent is sharing meaningful progress or a plan-changing discovery. Not blocking. | Read and acknowledge. No reply required unless you want to redirect. |
 
 **When a subagent asks:**
@@ -197,7 +197,7 @@ it as a `contact_supervisor` escalation.
 | Action | Behavior | Use When |
 |--------|----------|----------|
 | `send` | Fire-and-forget | You don't need a response |
-| `ask` | Blocks until reply (10 min timeout) | You need an answer to continue |
+| `ask` | Blocks until reply (10 min default, configurable with `PI_INTERCOM_ASK_TIMEOUT_MS`) | You need an answer to continue |
 | `reply` | Responds to the active or pending inbound ask | You were asked something and need to answer naturally |
 | `pending` | Lists unresolved inbound asks | You need to see who is waiting before replying |
 | `list` | Returns all sessions with live status | You need to discover targets or choose an idle peer |
@@ -301,7 +301,7 @@ If neither `cmux` nor `tmux` is available, skip this path and use normal `interc
 
 ### `ask` Limitations
 
-- **10-minute timeout**: If no reply comes within 10 minutes, the ask fails
+- **Configurable timeout**: If no reply arrives before the shared ask timeout, the ask fails. The default is 10 minutes; set `PI_INTERCOM_ASK_TIMEOUT_MS` to a positive millisecond value to change it.
 - **One at a time**: Cannot have multiple pending asks from the same session
 - **Cannot self-target**: A session cannot ask itself
 
@@ -402,11 +402,13 @@ if (!result.delivered) {
   await intercom({ action: "list" });
 }
 ```
+Replies to recently disconnected named senders can be queued by the broker and delivered if that sender reconnects with the same name. New sends still need a known live or recently disconnected target.
 
-**Ask timeout (after 10 minutes)**
+**Ask timeout**
 ```typescript
 // The ask will reject with a timeout error
-// Design your workflow so answers come within 10 minutes
+// Default: 10 minutes
+// Override: set PI_INTERCOM_ASK_TIMEOUT_MS to a positive millisecond value
 // For longer tasks, use send + follow-up ask pattern
 ```
 
@@ -490,7 +492,7 @@ intercom({ action: "send", to: "planner", message: "Task-3 complete. All done."
 ### Long-Running Task with Checkpoints
 
 ```typescript
-// For tasks that might exceed 10 minutes, use send + periodic asks
+// For tasks that might exceed the ask timeout, use send + periodic asks
 
 // 1. Initial send with full context
 intercom({

package/dist/extensions/pi-intercom/test/inline-message.test.ts

@@ -0,0 +1,184 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { stripVTControlCharacters } from "node:util";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { InlineMessageComponent } from "../ui/inline-message.ts";
+import type { Message, SessionInfo } from "../types.ts";
+
+const theme = {
+  fg(_name: string, text: string): string {
+    return text;
+  },
+};
+
+const from: SessionInfo = {
+  id: "session-12345678",
+  name: "sender",
+  cwd: "/tmp/project",
+  model: "model",
+  pid: 1,
+  startedAt: 0,
+  lastActivity: 0,
+};
+
+const message: Message = {
+  id: "message-1",
+  timestamp: 0,
+  content: {
+    text: "This is a long message that should use the available terminal width instead of a narrow fixed card.",
+  },
+};
+
+test("inline intercom messages render at the available terminal width", () => {
+  const component = new InlineMessageComponent(from, message, theme as any);
+
+  const lines = component.render(120);
+
+  assert.ok(lines.length > 0);
+  for (const line of lines) assert.equal(visibleWidth(line), 120);
+});
+
+test("expanded inline intercom messages show the full body without collapse controls", () => {
+  const component = new InlineMessageComponent(from, message, theme as any, "intercom({ action: \"reply\", message: \"...\" })");
+
+  const rendered = component.render(100).join("\n");
+
+  assert.match(rendered, /available terminal width/);
+  assert.match(rendered, /narrow fixed/);
+  assert.match(rendered, /card/);
+  assert.match(rendered, /To reply: intercom/);
+  assert.doesNotMatch(rendered, /Ctrl\+O/);
+});
+
+test("collapsed inline intercom messages keep preview, reply hint, and expand key visible", () => {
+  const component = new InlineMessageComponent(
+    from,
+    {
+      ...message,
+      content: {
+        text: "Alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu. This tail should only appear when expanded because the collapsed preview is intentionally brief.",
+        attachments: [{ type: "snippet", name: "note.txt", content: "important details" }],
+      },
+    },
+    theme as any,
+    "intercom({ action: \"reply\", message: \"...\" })",
+    undefined,
+    true,
+  );
+
+  const lines = component.render(120);
+  const rendered = lines.join("\n");
+
+  assert.equal(lines.length, 4);
+  for (const line of lines) assert.equal(visibleWidth(line), 120);
+  assert.match(rendered, /Alpha beta gamma/);
+  assert.doesNotMatch(rendered, /intentionally brief/);
+  assert.match(rendered, /To reply: intercom/);
+  assert.match(rendered, /Ctrl\+O/);
+  assert.match(rendered, /1 attachment/);
+});
+
+const roleCodes = {
+  accent: 31,
+  toolTitle: 32,
+  text: 33,
+  muted: 34,
+  dim: 35,
+} as const;
+
+function styledTheme(calls: string[] = []) {
+  return {
+    fg(name: keyof typeof roleCodes, text: string): string {
+      calls.push(name);
+      return `\u001b[${roleCodes[name]}m${text}\u001b[0m`;
+    },
+  };
+}
+
+test("inline message colors follow the tool-title, text, muted-border, and dim-metadata hierarchy", () => {
+  const calls: string[] = [];
+  const component = new InlineMessageComponent(
+    from,
+    {
+      ...message,
+      replyTo: "parent-message-id",
+      content: {
+        text: "Body copy",
+        attachments: [{ type: "snippet", name: "note.txt", content: "details" }],
+      },
+    },
+    styledTheme(calls) as any,
+    "intercom reply",
+  );
+
+  const lines = component.render(72);
+  const rendered = lines.join("\n");
+
+  assert.match(lines[0], /^\u001b\[34m╭\u001b\[0m\u001b\[32m 📨 From:/);
+  assert.match(rendered, /\u001b\[34m│\u001b\[0m\u001b\[33mBody copy\u001b\[0m/);
+  assert.match(rendered, /\u001b\[35m ↩ To reply: intercom reply\u001b\[0m/);
+  assert.match(rendered, /\u001b\[35m 📎 note\.txt\u001b\[0m/);
+  assert.match(rendered, /\u001b\[35m ↳ Reply to parent-m\u001b\[0m/);
+  assert.match(lines.at(-1)!, /^\u001b\[34m╰─+╯\u001b\[0m$/);
+  assert.ok(calls.includes("toolTitle"));
+  assert.ok(calls.includes("text"));
+  assert.ok(calls.includes("muted"));
+  assert.ok(calls.includes("dim"));
+  assert.ok(!calls.includes("accent"));
+});
+
+test("collapsed inline messages preserve the same hierarchy without accent", () => {
+  const calls: string[] = [];
+  const component = new InlineMessageComponent(from, message, styledTheme(calls) as any, "intercom reply", undefined, true);
+
+  const rendered = component.render(72).join("\n");
+
+  assert.match(rendered, /\u001b\[32m 📨 From:/);
+  assert.match(rendered, /\u001b\[33mThis is a long message/);
+  assert.match(rendered, /\u001b\[35m ↩ To reply:/);
+  assert.ok(!calls.includes("accent"));
+});
+
+test("semantic styling remains ANSI- and Unicode-width safe", () => {
+  const unicodeFrom = { ...from, name: "送信者🛰️", cwd: "/tmp/計画" };
+  const unicodeMessage = {
+    ...message,
+    content: { text: "\u001b[36m色付き本文\u001b[0m with emoji 🧪 and a long Unicode tail 計画計画計画" },
+  };
+  const component = new InlineMessageComponent(unicodeFrom, unicodeMessage, styledTheme() as any, "返信 📨");
+
+  for (const width of [18, 31, 52]) {
+    const lines = component.render(width);
+    assert.ok(lines.length > 0);
+    for (const line of lines) {
+      assert.equal(visibleWidth(line), width, `${width}: ${stripVTControlCharacters(line)}`);
+    }
+  }
+});
+
+test("inline messages pick up mutable theme proxy changes on rerender", () => {
+  const palette: Record<string, number> = { ...roleCodes };
+  const mutableTheme = new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (property !== "fg") return undefined;
+        return (name: string, text: string) => `\u001b[${palette[name]}m${text}\u001b[0m`;
+      },
+    },
+  );
+  const component = new InlineMessageComponent(from, message, mutableTheme as any);
+
+  const before = component.render(72).join("\n");
+  palette.toolTitle = 96;
+  palette.text = 97;
+  palette.muted = 90;
+  const after = component.render(72).join("\n");
+
+  assert.match(before, /\u001b\[32m 📨 From:/);
+  assert.match(after, /\u001b\[96m 📨 From:/);
+  assert.match(after, /\u001b\[97mThis is a long message/);
+  assert.match(after, /\u001b\[90m╭/);
+  assert.notEqual(before, after);
+});

package/dist/extensions/pi-intercom/test/overlay-width.test.ts

@@ -0,0 +1,66 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { ComposeOverlay } from "../ui/compose.ts";
+import { SessionListOverlay } from "../ui/session-list.ts";
+import type { SessionInfo } from "../types.ts";
+
+const theme = {
+  fg(_name: string, text: string): string {
+    return text;
+  },
+  bold(text: string): string {
+    return text;
+  },
+};
+
+const keybindings = {
+  matches(): boolean {
+    return false;
+  },
+  getKeys(id: string): string[] {
+    return id.includes("confirm") ? ["enter"] : ["escape", "ctrl+c"];
+  },
+};
+
+const session: SessionInfo = {
+  id: "session-12345678",
+  name: "subagent-chat-019ecaf6",
+  cwd: "/Users/envvar/.config/ghostty",
+  model: "bsy-deepseek-v4-pro",
+  pid: 1,
+  startedAt: 0,
+  lastActivity: 0,
+};
+
+function assertLineWidths(label: string, lines: string[], expectedWidth: number): void {
+  assert.ok(lines.length > 0, `${label} should render lines`);
+  for (const [index, line] of lines.entries()) {
+    assert.equal(visibleWidth(line), expectedWidth, `${label} line ${index} should match overlay width`);
+  }
+}
+
+test("compose overlay renders lines at the declared overlay width", () => {
+  const overlay = new ComposeOverlay(
+    { requestRender() {} } as any,
+    theme as any,
+    keybindings as any,
+    session,
+    "subagent-chat-019ecaf6",
+    { send: async () => ({ delivered: true, id: "message-1" }) } as any,
+    () => {},
+  );
+
+  for (const width of [1, 2, 20, 40, 72]) {
+    assertLineWidths("compose overlay", overlay.render(width), width);
+  }
+});
+
+test("session list overlay renders lines at the declared overlay width", () => {
+  const overlay = new SessionListOverlay(theme as any, keybindings as any, session, [session], () => {});
+
+  for (const width of [1, 2, 20, 50, 88]) {
+    assertLineWidths("session list overlay", overlay.render(width), width);
+  }
+});