@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-intercom/types.d.ts

@@ -0,0 +1,247 @@
+export declare const EXTENSION_BUS_FEATURE = "extension-bus-v1";
+export declare const EXACT_SEND_FEATURE = "exact-send-v1";
+export type DeliveryState = "socket_delivered" | "queued" | "failed" | "unknown";
+export interface DeliveryDetails {
+    delivery: DeliveryState;
+    code?: string;
+    retryable: boolean;
+    outcomeKnown: boolean;
+}
+export type HerdrLocation = {
+    status: "current";
+    workspace: {
+        id: string;
+        label: string;
+    };
+    tab: {
+        id: string;
+        label: string;
+    };
+    paneId: string;
+    /** Time when the broker requested the live Herdr snapshot. */
+    refreshedAt: number;
+} | {
+    status: "not_hosted";
+} | {
+    status: "unavailable";
+    paneId: string;
+    reason: "herdr_unavailable" | "unsupported" | "command_failed" | "pane_missing" | "invalid_response";
+    detail?: string;
+};
+export interface SessionInfo {
+    id: string;
+    /** Broker-owned lifetime of this live endpoint. */
+    endpointEpoch?: string;
+    name?: string;
+    /** True only when the extension synthesized name for an unnamed runtime. */
+    runtimeFallbackAlias?: boolean;
+    cwd: string;
+    model: string;
+    pid: number;
+    startedAt: number;
+    lastActivity: number;
+    status?: string;
+    peerUid?: number;
+    trustedLocal?: boolean;
+    /** Live context-window usage, pushed via presence from the source session's
+     *  getContextUsage(). contextPct is 0..100 (rounded); contextTokens /
+     *  contextWindow are raw token counts. All optional: unknown right after a
+     *  compaction (before the next assistant response), when no model is selected,
+     *  or on older clients that never report it. */
+    contextPct?: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    /** tmux pane id (e.g. "%212") of the session's terminal, read from
+     *  $TMUX_PANE at registration. Present only when the session runs inside a
+     *  tmux pane; absent for cloud, headless, IDE-embedded, or Herdr sessions.
+     *  The pane id is immutable for the process lifetime — unlike the window
+     *  name, which is mutable — so a peer can live-resolve the current window
+     *  from it via tmux when it needs to introspect or drive that pane. */
+    tmuxPane?: string;
+    /** Launch-time Herdr pane alias. It may differ from the current pane id after a move. */
+    herdrPaneId?: string;
+    /** Present on list responses. `current` is freshly resolved for that request;
+     *  other states explicitly distinguish non-Herdr sessions from failures. */
+    herdrLocation?: HerdrLocation;
+}
+export interface CrossMachineOrigin {
+    name: string;
+    sessionId: string;
+    machine: string;
+}
+export interface CrossMachineProvenance {
+    type: "ssh-relay";
+    version: 1;
+    origin: CrossMachineOrigin;
+    trust: "ssh-asserted";
+}
+export interface Message {
+    id: string;
+    timestamp: number;
+    senderSequence?: number;
+    brokerReceivedAt?: number;
+    brokerDeliveredAt?: number;
+    receiverReceivedAt?: number;
+    injectedAt?: number;
+    supersedes?: string;
+    retryOf?: string;
+    replyTo?: string;
+    expectsReply?: boolean;
+    provenance?: MessageProvenance;
+    crossMachine?: CrossMachineProvenance;
+    content: {
+        text: string;
+        attachments?: Attachment[];
+    };
+}
+export interface MessageProvenance {
+    type: "extension_outbox";
+    extensionId: string;
+    extensionName: string;
+    requestId: string;
+}
+export interface Attachment {
+    type: "file" | "snippet" | "context";
+    name: string;
+    content: string;
+    language?: string;
+}
+export type MessageReceiptStatus = "receiver_received" | "queued" | "injected" | "acknowledged" | "expired" | "cancelled" | "superseded" | "cancellation_requested";
+export interface MessageReceipt {
+    messageId: string;
+    status: MessageReceiptStatus;
+    timestamp: number;
+    detail?: string;
+}
+export type MessageControlAction = "cancel" | "supersede";
+export interface MessageControl {
+    messageId: string;
+    action: MessageControlAction;
+    timestamp: number;
+    supersededBy?: string;
+    detail?: string;
+}
+export interface ExtensionCapability {
+    namespace: string;
+    ownerEligible: boolean;
+}
+export type SessionRegistration = Omit<SessionInfo, "id" | "endpointEpoch" | "peerUid" | "trustedLocal" | "herdrLocation"> & {
+    extensions?: ExtensionCapability[];
+    /** Broker-only join hint; never returned in the public roster. */
+    herdrSessionPath?: string;
+};
+export type ClientMessage = {
+    type: "register";
+    session: SessionRegistration;
+    sessionId?: string;
+    stateId?: string;
+    scopeId?: string;
+} | {
+    type: "unregister";
+} | {
+    type: "extension_capabilities_update";
+    extensions: ExtensionCapability[];
+} | {
+    type: "list";
+    requestId: string;
+} | {
+    type: "send";
+    to: string;
+    message: Message;
+    targetId?: string;
+    targetEpoch?: string;
+} | {
+    type: "message_receipt";
+    receipt: MessageReceipt;
+} | {
+    type: "cancel_message";
+    messageId: string;
+} | {
+    type: "cancel_ask";
+    messageId: string;
+} | {
+    type: "presence";
+    name?: string;
+    runtimeFallbackAlias?: boolean;
+    status?: string;
+    model?: string;
+    contextPct?: number | null;
+    contextTokens?: number | null;
+    contextWindow?: number | null;
+} | {
+    type: "extension_publish";
+    namespace: string;
+    audience: "owner" | "capable";
+    ownerEpoch?: string;
+    ownerOnly?: boolean;
+    payload: unknown;
+} | {
+    type: "extension_state_commit";
+    namespace: string;
+    ownerEpoch: string;
+    expectedRevision: number;
+    payload: unknown;
+};
+export type BrokerMessage = {
+    type: "registered";
+    sessionId: string;
+    features?: string[];
+} | {
+    type: "sessions";
+    requestId: string;
+    sessions: SessionInfo[];
+} | {
+    type: "message";
+    from: SessionInfo;
+    message: Message;
+} | {
+    type: "presence_update";
+    session: SessionInfo;
+} | {
+    type: "session_joined";
+    session: SessionInfo;
+} | {
+    type: "session_left";
+    sessionId: string;
+} | {
+    type: "error";
+    error: string;
+} | ({
+    type: "delivered";
+    messageId: string;
+} & DeliveryDetails) | ({
+    type: "delivery_failed";
+    messageId: string;
+    reason: string;
+} & DeliveryDetails) | {
+    type: "message_receipt";
+    from: SessionInfo;
+    receipt: MessageReceipt;
+} | {
+    type: "message_control";
+    from: SessionInfo;
+    control: MessageControl;
+} | {
+    type: "extension_owner";
+    namespace: string;
+    ownerId?: string;
+    ownerEpoch?: string;
+} | {
+    type: "extension_message";
+    namespace: string;
+    fromSessionId: string;
+    ownerId?: string;
+    ownerEpoch?: string;
+    payload: unknown;
+} | {
+    type: "extension_state";
+    namespace: string;
+    revision: number;
+    payload: unknown;
+} | {
+    type: "extension_state_result";
+    namespace: string;
+    committed: boolean;
+    revision: number;
+    reason?: string;
+};

package/dist/extensions/pi-intercom/types.js

@@ -0,0 +1,2 @@
+export const EXTENSION_BUS_FEATURE = "extension-bus-v1";
+export const EXACT_SEND_FEATURE = "exact-send-v1";

package/dist/extensions/pi-intercom/types.ts

@@ -10,6 +10,23 @@ export interface DeliveryDetails {
   outcomeKnown: boolean;
 }
 
+export type HerdrLocation =
+  | {
+      status: "current";
+      workspace: { id: string; label: string };
+      tab: { id: string; label: string };
+      paneId: string;
+      /** Time when the broker requested the live Herdr snapshot. */
+      refreshedAt: number;
+    }
+  | { status: "not_hosted" }
+  | {
+      status: "unavailable";
+      paneId: string;
+      reason: "herdr_unavailable" | "unsupported" | "command_failed" | "pane_missing" | "invalid_response";
+      detail?: string;
+    };
+
 export interface SessionInfo {
   id: string;
   /** Broker-owned lifetime of this live endpoint. */
@@ -40,6 +57,24 @@ export interface SessionInfo {
    *  name, which is mutable — so a peer can live-resolve the current window
    *  from it via tmux when it needs to introspect or drive that pane. */
   tmuxPane?: string;
+  /** Launch-time Herdr pane alias. It may differ from the current pane id after a move. */
+  herdrPaneId?: string;
+  /** Present on list responses. `current` is freshly resolved for that request;
+   *  other states explicitly distinguish non-Herdr sessions from failures. */
+  herdrLocation?: HerdrLocation;
+}
+
+export interface CrossMachineOrigin {
+  name: string;
+  sessionId: string;
+  machine: string;
+}
+
+export interface CrossMachineProvenance {
+  type: "ssh-relay";
+  version: 1;
+  origin: CrossMachineOrigin;
+  trust: "ssh-asserted";
 }
 
 export interface Message {
@@ -55,6 +90,7 @@ export interface Message {
   replyTo?: string;
   expectsReply?: boolean;
   provenance?: MessageProvenance;
+  crossMachine?: CrossMachineProvenance;
   content: {
     text: string;
     attachments?: Attachment[];
@@ -99,8 +135,10 @@ export interface ExtensionCapability {
   ownerEligible: boolean;
 }
 
-export type SessionRegistration = Omit<SessionInfo, "id" | "endpointEpoch" | "peerUid" | "trustedLocal"> & {
+export type SessionRegistration = Omit<SessionInfo, "id" | "endpointEpoch" | "peerUid" | "trustedLocal" | "herdrLocation"> & {
   extensions?: ExtensionCapability[];
+  /** Broker-only join hint; never returned in the public roster. */
+  herdrSessionPath?: string;
 };
 
 export type ClientMessage =

package/dist/extensions/pi-intercom/ui/handover-picker.ts

@@ -0,0 +1,318 @@
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { Input, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { KeybindingsManager, Theme } from "@selesai/code";
+import type { RemoteAgent, SavedMachine } from "../cross-machine-discovery.ts";
+import type { SessionInfo } from "../types.ts";
+import { herdrLocationText, middleTruncate, shortSessionId } from "./session-list.ts";
+
+const PICKER_WIDTH = 88;
+const MAX_BODY_LINES = 24;
+const CONTEXT_WARNING_PCT = 80;
+
+export type HandoverPickerTarget =
+  | { kind: "local"; session: SessionInfo }
+  | { kind: "project" }
+  | { kind: "remote"; target: string };
+
+export interface HandoverPickerResult {
+  target: HandoverPickerTarget;
+  goal?: string;
+}
+
+/** Remote listing runs over SSH through Herdr, so it is injected. */
+export interface RemoteSessionLister {
+  listMachines(): Promise<SavedMachine[]>;
+  listAgents(machine: SavedMachine): Promise<RemoteAgent[]>;
+}
+
+export interface HandoverPickerOptions {
+  currentSession: SessionInfo;
+  sessions: SessionInfo[];
+  lister: RemoteSessionLister;
+  preselectSessionId?: string;
+}
+
+type MachineEntry =
+  | { machine: SavedMachine; state: "fetching" }
+  | { machine: SavedMachine; state: "done"; agents: RemoteAgent[] }
+  | { machine: SavedMachine; state: "error"; error: string };
+
+type RemoteState =
+  | { state: "idle" }
+  | { state: "listing" }
+  | { state: "error"; error: string }
+  | { state: "machines"; machines: MachineEntry[] };
+
+type Item =
+  | { kind: "local"; session: SessionInfo }
+  | { kind: "project" }
+  | { kind: "fetch" }
+  | { kind: "remote"; machine: SavedMachine; agent: RemoteAgent };
+
+/** pi-subagents registers children under a "subagent-<agent>-<run>" session id; their name is the task text. */
+function isSubagentChild(session: SessionInfo): boolean {
+  return session.id.startsWith("subagent-");
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export class HandoverPicker implements Component {
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly keybindings: KeybindingsManager;
+  private readonly lister: RemoteSessionLister;
+  private readonly done: (result: HandoverPickerResult | undefined) => void;
+  private readonly localSessions: SessionInfo[];
+  private remote: RemoteState = { state: "idle" };
+  private closed = false;
+  private selectedIndex = 0;
+  private focus: "list" | "task" = "list";
+  private readonly taskInput = new Input();
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keybindings: KeybindingsManager,
+    options: HandoverPickerOptions,
+    done: (result: HandoverPickerResult | undefined) => void,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.lister = options.lister;
+    this.done = done;
+    this.localSessions = options.sessions
+      .filter((session) => session.id !== options.currentSession.id && !isSubagentChild(session))
+      .sort((a, b) => b.lastActivity - a.lastActivity);
+    const preselected = this.localSessions.findIndex((session) => session.id === options.preselectSessionId);
+    if (preselected >= 0) {
+      this.selectedIndex = preselected;
+      this.focus = "task";
+    }
+  }
+
+  private items(): Item[] {
+    const items: Item[] = this.localSessions.map((session) => ({ kind: "local", session }));
+    items.push({ kind: "project" }, { kind: "fetch" });
+    if (this.remote.state === "machines") {
+      for (const entry of this.remote.machines) {
+        if (entry.state !== "done") continue;
+        for (const agent of entry.agents) items.push({ kind: "remote", machine: entry.machine, agent });
+      }
+    }
+    return items;
+  }
+
+  private close(result: HandoverPickerResult | undefined): void {
+    this.closed = true;
+    this.done(result);
+  }
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.close(undefined);
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.input.tab")) {
+      this.focus = this.focus === "list" ? "task" : "list";
+      this.tui.requestRender();
+      return;
+    }
+    const items = this.items();
+    if (this.keybindings.matches(data, "tui.select.up")) {
+      this.selectedIndex = this.selectedIndex === 0 ? items.length - 1 : this.selectedIndex - 1;
+      this.tui.requestRender();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.down")) {
+      this.selectedIndex = this.selectedIndex >= items.length - 1 ? 0 : this.selectedIndex + 1;
+      this.tui.requestRender();
+      return;
+    }
+    if (this.keybindings.matches(data, "tui.select.confirm")) {
+      const item = items[this.selectedIndex];
+      if (item) this.activate(item);
+      return;
+    }
+    if (this.focus !== "task") return;
+    this.taskInput.handleInput(data);
+    this.tui.requestRender();
+  }
+
+  private activate(item: Item): void {
+    if (item.kind === "fetch") {
+      void this.fetchRemote();
+      return;
+    }
+    const goal = this.taskInput.getValue().trim() || undefined;
+    const target: HandoverPickerTarget = item.kind === "remote"
+      ? { kind: "remote", target: `${item.agent.sessionId ?? item.agent.name}@${item.machine.label}` }
+      : item;
+    this.close({ target, goal });
+  }
+
+  private async fetchRemote(): Promise<void> {
+    const busy = this.remote.state === "listing"
+      || (this.remote.state === "machines" && this.remote.machines.some((entry) => entry.state === "fetching"));
+    if (busy) return;
+    this.remote = { state: "listing" };
+    // A new fetch drops the previous remote rows.
+    this.selectedIndex = Math.min(this.selectedIndex, this.items().length - 1);
+    this.tui.requestRender();
+
+    let machines: SavedMachine[];
+    try {
+      machines = (await this.lister.listMachines()).filter((machine) => machine.enabled);
+    } catch (error) {
+      if (this.closed) return;
+      this.remote = { state: "error", error: errorMessage(error) };
+      this.tui.requestRender();
+      return;
+    }
+    if (this.closed) return;
+    const entries: MachineEntry[] = machines.map((machine) => ({ machine, state: "fetching" }));
+    this.remote = { state: "machines", machines: entries };
+    this.tui.requestRender();
+
+    await Promise.all(machines.map(async (machine, index) => {
+      let entry: MachineEntry;
+      try {
+        entry = { machine, state: "done", agents: await this.lister.listAgents(machine) };
+      } catch (error) {
+        entry = { machine, state: "error", error: errorMessage(error) };
+      }
+      if (this.closed) return;
+      // Earlier machines can finish later, so keep the highlighted remote session selected.
+      const selected = this.items()[this.selectedIndex];
+      entries[index] = entry;
+      if (selected?.kind === "remote") {
+        this.selectedIndex = this.items().findIndex((item) => item.kind === "remote" && item.agent === selected.agent);
+      }
+      this.tui.requestRender();
+    }));
+  }
+
+  private remoteLabel(machine: SavedMachine, agent: RemoteAgent): string {
+    const name = agent.sessionId && agent.name === agent.sessionId ? shortSessionId(agent.sessionId) : agent.name;
+    return `${name}@${machine.label}`;
+  }
+
+  render(width: number): string[] {
+    const innerWidth = Math.max(1, Math.min(width, PICKER_WIDTH));
+    if (innerWidth === 1) {
+      return [this.theme.fg("accent", "│")];
+    }
+
+    const contentWidth = Math.max(0, innerWidth - 2);
+    const border = (text: string) => this.theme.fg("accent", text);
+    const separator = border(`├${"─".repeat(contentWidth)}┤`);
+    const row = (text = "") => {
+      const clipped = truncateToWidth(text, contentWidth, "", true);
+      return `${border("│")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))}${border("│")}`;
+    };
+    const dim = (text: string) => this.theme.fg("dim", text);
+    const errorRows = (text: string) => wrapTextWithAnsi(text, Math.max(1, contentWidth - 2))
+      .map((line) => row(this.theme.fg("error", `  ${line}`)));
+    const pathWidth = Math.max(8, contentWidth - 4);
+
+    const items = this.items();
+    const itemIndex = new Map<Item, number>(items.map((item, index) => [item, index]));
+    const body: string[] = [];
+    let selectedStart = 0;
+    let selectedEnd = 0;
+    // `suffix` follows the title and keeps its own colors; `details` are dim secondary lines.
+    const pushItem = (item: Item, title: string, details: string[] = [], suffix = "") => {
+      const selected = itemIndex.get(item) === this.selectedIndex;
+      if (selected) selectedStart = body.length;
+      const prefix = selected ? this.theme.fg("accent", "→ ") : "  ";
+      body.push(row(`${prefix}${selected ? this.theme.fg("accent", title) : title}${suffix}`), ...details.map((line) => row(`  ${dim(line)}`)));
+      if (selected) selectedEnd = body.length;
+    };
+
+    body.push(row(this.theme.bold(" This machine")));
+    for (const item of items) {
+      if (item.kind !== "local") continue;
+      const session = item.session;
+      const status = session.status
+        ? ` · ${session.status.split(" · ")[0] === "idle" ? dim(session.status) : this.theme.fg("warning", session.status)}`
+        : "";
+      const pct = typeof session.contextPct === "number"
+        ? ` · ${session.contextPct >= CONTEXT_WARNING_PCT ? this.theme.fg("warning", `${session.contextPct}% ctx`) : dim(`${session.contextPct}% ctx`)}`
+        : "";
+      const location = herdrLocationText(session);
+      pushItem(
+        item,
+        `${session.name || "Unnamed session"} (${shortSessionId(session.id)})`,
+        [`${middleTruncate(session.cwd, pathWidth)} • ${session.model}`, ...(location ? [location] : [])],
+        `${status}${pct}`,
+      );
+    }
+    pushItem(items.find((item) => item.kind === "project")!, "+ New session in a project path…");
+
+    body.push(separator, row(this.theme.bold(" Other machines")));
+    pushItem(
+      items.find((item) => item.kind === "fetch")!,
+      this.remote.state === "idle" ? "Fetch sessions from other machines" : "Fetch again",
+    );
+    if (this.remote.state === "listing") {
+      body.push(row(dim("  Listing saved Herdr machines…")));
+    } else if (this.remote.state === "error") {
+      body.push(...errorRows(this.remote.error));
+    } else if (this.remote.state === "machines") {
+      if (this.remote.machines.length === 0) body.push(row(dim("  No enabled saved Herdr machines.")));
+      for (const entry of this.remote.machines) {
+        if (entry.state === "fetching") {
+          body.push(row(dim(`  ${entry.machine.label}: fetching…`)));
+        } else if (entry.state === "error") {
+          body.push(...errorRows(entry.error));
+        } else if (entry.agents.length === 0) {
+          body.push(row(dim(`  ${entry.machine.label}: no Pi sessions`)));
+        } else {
+          for (const agent of entry.agents) {
+            const item = items.find((candidate) => candidate.kind === "remote" && candidate.agent === agent)!;
+            pushItem(
+              item,
+              this.remoteLabel(entry.machine, agent),
+              agent.cwd ? [middleTruncate(agent.cwd, pathWidth)] : [],
+              agent.status ? ` · ${agent.status === "idle" ? dim(agent.status) : this.theme.fg("warning", agent.status)}` : "",
+            );
+          }
+        }
+      }
+    }
+
+    let visible = body;
+    if (body.length > MAX_BODY_LINES) {
+      const selectedLength = selectedEnd - selectedStart;
+      const start = Math.max(0, Math.min(
+        selectedStart - Math.floor((MAX_BODY_LINES - 1 - selectedLength) / 2),
+        body.length - (MAX_BODY_LINES - 1),
+      ));
+      visible = [...body.slice(start, start + MAX_BODY_LINES - 1), row(dim(` ${this.selectedIndex + 1}/${items.length}`))];
+    }
+
+    const taskLabel = " Next task (optional): ";
+    const taskLine = this.focus === "task"
+      ? `${taskLabel}${this.taskInput.render(Math.max(1, contentWidth - visibleWidth(taskLabel)))[0] ?? ""}`
+      : dim(`${taskLabel}${this.taskInput.getValue()}`);
+
+    const keys = (id: string) => this.keybindings.getKeys(id as Parameters<KeybindingsManager["getKeys"]>[0]).join("/");
+    const footer = `${keys("tui.select.confirm")}: Hand over • ${keys("tui.input.tab")}: ${this.focus === "list" ? "Next task" : "List"} • ${keys("tui.select.cancel")}: Close`;
+
+    return [
+      border(`╭${"─".repeat(contentWidth)}╮`),
+      row(this.theme.bold(" Hand over to")),
+      separator,
+      ...visible,
+      separator,
+      row(taskLine),
+      separator,
+      row(dim(` ${footer}`)),
+      border(`╰${"─".repeat(contentWidth)}╯`),
+    ];
+  }
+}

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

@@ -2,6 +2,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Theme } from "@selesai/code";
 import type { SessionInfo, Message } from "../types.ts";
+import { relaySenderName } from "../cross-machine-envelope.ts";
 
 export class InlineMessageComponent implements Component {
   private from: SessionInfo;
@@ -36,7 +37,13 @@ export class InlineMessageComponent implements Component {
   render(width: number): string[] {
     const lines: string[] = [];
     const borderChar = "─";
-    const senderName = this.from.name || this.from.id.slice(0, 8);
+    const remoteSender = this.message.crossMachine && relaySenderName(this.message.crossMachine.origin);
+    const senderName = remoteSender
+      ? `${remoteSender} · unverified cross-machine`
+      : this.from.name || this.from.id.slice(0, 8);
+    const replyLabel = remoteSender
+      ? `To send a new message to ${remoteSender}:`
+      : "To reply:";
     if (width < 3) {
       return [truncateToWidth(`From ${senderName}`, width)];
     }
@@ -62,7 +69,7 @@ export class InlineMessageComponent implements Component {
       lines.push(frameLine(this.theme.fg("text", this.collapsedPreview)));
 
       const meta: string[] = [];
-      if (this.replyCommand) meta.push(`To reply: ${this.replyCommand}`);
+      if (this.replyCommand) meta.push(`${replyLabel} ${this.replyCommand}`);
       if (this.message.content.attachments?.length) {
         const count = this.message.content.attachments.length;
         meta.push(`${count} attachment${count === 1 ? "" : "s"}`);
@@ -88,7 +95,7 @@ export class InlineMessageComponent implements Component {
 
     if (this.replyCommand) {
       lines.push(frameLine(""));
-      const replyLines = wrapTextWithAnsi(this.theme.fg("dim", ` To reply: ${this.replyCommand}`), bodyWidth);
+      const replyLines = wrapTextWithAnsi(this.theme.fg("dim", ` ${replyLabel} ${this.replyCommand}`), bodyWidth);
       for (const line of replyLines) {
         lines.push(frameLine(line));
       }