@agentprojectcontext/apx 1.14.1 → 1.15.1

package/src/cli/commands/sys.js

@@ -13,6 +13,12 @@ import {
 
 const MAIN_PALETTE_OPTIONS = ["Switch model", "Connect provider", "Open editor", "Exit"];
 
+// Message Actions overlay options for a queued message
+const MSG_ACTION_SEND   = "Send now  (interrupt current)";
+const MSG_ACTION_COPY   = "Copy message text";
+const MSG_ACTION_QUESTION = "Ask about this...";
+const MSG_ACTION_REMOVE = "Remove from queue";
+
 export async function cmdSys(args) {
   const pid = await resolveProjectId(args?.flags?.project);
   const cfg = readConfig();
@@ -34,16 +40,25 @@ export async function cmdSys(args) {
     usage: { input: 0, output: 0, percent: 0 },
     chatScrollOffset: 0,
     transcript: [],
+    // Message Actions overlay state
+    inMsgActions: false,
+    msgActionsTarget: null,   // { text } of the targeted message
+    msgActionsSelection: 0,
+    msgActionsOptions: [MSG_ACTION_SEND, MSG_ACTION_COPY, MSG_ACTION_QUESTION, MSG_ACTION_REMOVE],
   };
 
   const previousMessages = [];
   const pendingPrompts = [];
   let restored = false;
   let isRequesting = false;
+  // AbortController for the current in-flight LLM request
+  let currentAbortCtrl = null;
 
   function restoreTerminal() {
     if (restored) return;
     restored = true;
+    // Disable mouse tracking before exit
+    process.stdout.write("\x1b[?1000l\x1b[?1015l\x1b[?1006l");
     if (process.stdin.isTTY) process.stdin.setRawMode(false);
     process.stdout.write(C.reset + C.showCursor + C.resetBg + C.altOff);
   }
@@ -67,6 +82,8 @@ export async function cmdSys(args) {
   readline.emitKeypressEvents(process.stdin);
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdout.write(C.altOn + C.setBgBlack + C.showCursor + C.bg);
+  // Enable xterm mouse button tracking (X10 + SGR extended for wide terminals)
+  process.stdout.write("\x1b[?1000h\x1b[?1015h\x1b[?1006h");
   process.once("exit", restoreTerminal);
   process.once("SIGINT", close);
   process.once("SIGTERM", close);
@@ -75,25 +92,72 @@ export async function cmdSys(args) {
 
   renderScreen();
 
+  // Handle raw mouse tracking bytes before readline keypress
+  process.stdin.on("data", (chunk) => {
+    const raw = typeof chunk === "string" ? chunk : chunk.toString("binary");
+    // SGR mouse: ESC [ < Pb ; Px ; Py M/m
+    const sgrMatch = raw.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+    if (sgrMatch) {
+      const btn = parseInt(sgrMatch[1], 10);
+      const col = parseInt(sgrMatch[2], 10) - 1;
+      const row = parseInt(sgrMatch[3], 10) - 1;
+      const press = sgrMatch[4] === "M";
+      if (press && btn === 0) {
+        handleMouseClick(col, row, state, pendingPrompts, renderScreen, () => {
+          // interrupt callback: abort current request then flush queue
+          if (currentAbortCtrl) currentAbortCtrl.abort();
+        });
+      }
+      return;
+    }
+  });
+
   process.stdin.on("keypress", async (str, key) => {
     if (key.ctrl && key.name === "c") {
+      // If a request is running, interrupt it first; second Ctrl-C exits
+      if (isRequesting && currentAbortCtrl) {
+        currentAbortCtrl.abort();
+        return;
+      }
       close();
     }
 
+    // Ctrl+I = interrupt current request and immediately send first queued prompt
+    if (key.ctrl && key.name === "i" && isRequesting) {
+      if (currentAbortCtrl) currentAbortCtrl.abort();
+      return;
+    }
+
     if (key.ctrl && key.name === "p") {
       state.inCommandPalette = !state.inCommandPalette;
+      state.inMsgActions = false;
       resetPalette();
       renderScreen();
       return;
     }
 
-    if (key.name === "escape" && state.inCommandPalette) {
-      if (state.paletteState !== "main") {
-        resetPalette();
-      } else {
-        state.inCommandPalette = false;
+    if (key.name === "escape") {
+      if (state.inMsgActions) {
+        state.inMsgActions = false;
+        state.msgActionsTarget = null;
+        renderScreen();
+        return;
       }
-      renderScreen();
+      if (state.inCommandPalette) {
+        if (state.paletteState !== "main") {
+          resetPalette();
+        } else {
+          state.inCommandPalette = false;
+        }
+        renderScreen();
+        return;
+      }
+    }
+
+    if (state.inMsgActions) {
+      await handleMsgActionsKey(key, state, pendingPrompts, renderScreen, () => {
+        if (currentAbortCtrl) currentAbortCtrl.abort();
+      });
       return;
     }
 
@@ -105,14 +169,23 @@ export async function cmdSys(args) {
     if (handleScrollKey(key, state, renderScreen)) return;
 
     if (isReturnKey(key)) {
+      if (isExitCommand(state.inputText)) {
+        close();
+        return;
+      }
+
       if (isRequesting) {
         queuePrompt(state, pendingPrompts, renderScreen);
         return;
       }
 
       isRequesting = true;
-      await submitPromptQueue(pid, state, previousMessages, pendingPrompts, renderScreen, close);
+      await submitPromptQueue(
+        pid, state, previousMessages, pendingPrompts, renderScreen, close,
+        (ctrl) => { currentAbortCtrl = ctrl; }
+      );
       isRequesting = false;
+      currentAbortCtrl = null;
       return;
     }
 
@@ -120,10 +193,123 @@ export async function cmdSys(args) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Mouse click → Message Actions overlay
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine if a click at (col, row) lands on a queued user message bubble,
+ * and if so open the Message Actions overlay for it.
+ */
+function handleMouseClick(col, row, state, pendingPrompts, renderScreen, onInterrupt) {
+  if (!state.hasStarted) return;
+
+  // Find the message bubble that was clicked. 
+  // We look for both queued and regular messages in the transcript.
+  // Transcript is rendered from bottom to top in terms of logic, 
+  // but we'll use a simple heuristic for now.
+  const allUserMessages = state.transcript.filter(t => t.type === "user");
+  if (allUserMessages.length === 0) return;
+
+  const { width } = { width: process.stdout.columns || 80 };
+  if (col > Math.floor(width * 0.8)) return;
+
+  // For now, just pick the most recent one if clicked in the main area.
+  // In a real app we'd map row to transcript index precisely.
+  state.inMsgActions = true;
+  state.msgActionsTarget = allUserMessages[allUserMessages.length - 1];
+  state.msgActionsSelection = 0;
+  
+  // Filter options: "Send now" only for queued items
+  const isQueued = state.msgActionsTarget.meta === "queued";
+  state.msgActionsOptions = isQueued 
+    ? [MSG_ACTION_SEND, MSG_ACTION_COPY, MSG_ACTION_QUESTION, MSG_ACTION_REMOVE]
+    : [MSG_ACTION_COPY, MSG_ACTION_QUESTION];
+
+  renderScreen();
+}
+
+/** Keyboard nav inside the Message Actions overlay */
+async function handleMsgActionsKey(key, state, pendingPrompts, renderScreen, onInterrupt) {
+  if (key.name === "up") {
+    state.msgActionsSelection = Math.max(0, state.msgActionsSelection - 1);
+    renderScreen();
+    return;
+  }
+  if (key.name === "down") {
+    state.msgActionsSelection = Math.min(
+      state.msgActionsOptions.length - 1,
+      state.msgActionsSelection + 1
+    );
+    renderScreen();
+    return;
+  }
+  if (key.name !== "return") {
+    renderScreen();
+    return;
+  }
+
+  const selected = state.msgActionsOptions[state.msgActionsSelection];
+  const target = state.msgActionsTarget;
+
+  // Close overlay first
+  state.inMsgActions = false;
+  state.msgActionsTarget = null;
+
+  if (selected === MSG_ACTION_REMOVE) {
+    // Remove from pendingPrompts and transcript
+    const idx = pendingPrompts.findIndex((p) => p.text === target?.text);
+    if (idx >= 0) pendingPrompts.splice(idx, 1);
+    const tidx = state.transcript.indexOf(target);
+    if (tidx >= 0) state.transcript.splice(tidx, 1);
+    renderScreen();
+    return;
+  }
+
+  if (selected === MSG_ACTION_COPY) {
+    // Best-effort clipboard via pbcopy (macOS) / xclip (Linux)
+    try {
+      const { execSync } = await import("node:child_process");
+      const cmd = process.platform === "darwin" ? "pbcopy" : "xclip -selection clipboard";
+      execSync(cmd, { input: target?.text || "", stdio: ["pipe", "ignore", "ignore"] });
+    } catch {}
+    state.transcript.push({ type: "status", text: "Copied to clipboard" });
+    renderScreen();
+    return;
+  }
+
+  if (selected === MSG_ACTION_QUESTION) {
+    const text = target?.text || "";
+    state.inputText = `Pregunta sobre esto: "${text.slice(0, 50)}${text.length > 50 ? "..." : ""}"\n\n`;
+    state.cursorIndex = state.inputText.length;
+    renderScreen();
+    return;
+  }
+
+  if (selected === MSG_ACTION_SEND) {
+    // Promote the queued item to front of queue, then interrupt current request
+    const idx = pendingPrompts.findIndex((p) => p.text === target?.text);
+    if (idx > 0) {
+      const [entry] = pendingPrompts.splice(idx, 1);
+      pendingPrompts.unshift(entry);
+    }
+    // Signal the interrupt — the running submitPromptQueue will pick it up
+    onInterrupt();
+    renderScreen();
+    return;
+  }
+
+  renderScreen();
+}
+
 export function isReturnKey(key) {
   return key?.name === "return" || key?.name === "enter";
 }
 
+export function isExitCommand(text) {
+  return /^(exit|quit)$/i.test(String(text || "").trim());
+}
+
 export function handleScrollKey(key, state, renderScreen) {
   if (!state.hasStarted || !key) return false;
   const pageSize = key.name === "pageup" || key.name === "pagedown" ? 8 : 3;
@@ -329,11 +515,15 @@ function queuePrompt(state, pendingPrompts, renderScreen) {
   renderScreen();
 }
 
-async function submitPromptQueue(pid, state, previousMessages, pendingPrompts, renderScreen, close) {
+async function submitPromptQueue(
+  pid, state, previousMessages, pendingPrompts, renderScreen, close,
+  setAbortCtrl = () => {}
+) {
   const firstText = state.inputText.trim();
   if (!firstText) return;
-  if (firstText.toLowerCase() === "exit" || firstText.toLowerCase() === "quit") {
+  if (isExitCommand(firstText)) {
     close();
+    return;
   }
 
   state.hasStarted = true;
@@ -343,20 +533,29 @@ async function submitPromptQueue(pid, state, previousMessages, pendingPrompts, r
 
   const firstItem = { type: "user", text: firstText };
   state.transcript.push(firstItem);
-  await runPrompt(pid, state, previousMessages, renderScreen, firstText, firstItem);
+  await runPrompt(
+    pid, state, previousMessages, renderScreen, firstText, firstItem, setAbortCtrl
+  );
 
   while (pendingPrompts.length > 0) {
     const queued = pendingPrompts.shift();
     delete queued.item.meta;
-    await runPrompt(pid, state, previousMessages, renderScreen, queued.text, queued.item);
+    await runPrompt(
+      pid, state, previousMessages, renderScreen, queued.text, queued.item, setAbortCtrl
+    );
   }
 }
 
-async function runPrompt(pid, state, previousMessages, renderScreen, text, userItem) {
+async function runPrompt(
+  pid, state, previousMessages, renderScreen, text, userItem,
+  setAbortCtrl = () => {}
+) {
   appendLiveItem(state, { type: "status", text: "Thinking...", active: true });
   renderScreen();
 
   const startTime = Date.now();
+  const abortCtrl = http.createAbortController();
+  setAbortCtrl(abortCtrl);
 
   try {
     const cwd = process.cwd();
@@ -372,28 +571,49 @@ async function runPrompt(pid, state, previousMessages, renderScreen, text, userI
     };
 
     let result;
+    let interrupted = false;
     try {
       result = await http.streamPost(
         `/projects/${pid}/super-agent/chat/stream`,
         body,
-        (event) => handleProgressEvent(event, state, renderScreen)
+        (event) => handleProgressEvent(event, state, renderScreen),
+        { signal: abortCtrl.signal }
       );
     } catch (e) {
-      if (e.status !== 404) throw e;
-      result = await http.post(`/projects/${pid}/super-agent/chat`, body);
-      removeStatus(state);
-      for (const trace of result.trace || []) {
-        appendLiveItem(state, { type: "tool", trace });
+      if (abortCtrl.signal.aborted) {
+        // Interrupted by user — show notice and continue to next queued prompt
+        interrupted = true;
+        removeStatus(state);
+        appendLiveItem(state, {
+          type: "status",
+          text: `\u26a1 Interrupted — ${text.slice(0, 60)}${text.length > 60 ? "\u2026" : ""}`,
+        });
+      } else if (e.status !== 404) {
+        throw e;
+      } else {
+        result = await http.post(
+          `/projects/${pid}/super-agent/chat`, body,
+          { signal: abortCtrl.signal }
+        );
+        removeStatus(state);
+        for (const trace of result.trace || []) {
+          appendLiveItem(state, { type: "tool", trace });
+        }
       }
     }
 
-    completeSuperAgentResult(result, text, startTime, state, previousMessages);
+    if (!interrupted && result) {
+      completeSuperAgentResult(result, text, startTime, state, previousMessages);
+    }
   } catch (e) {
-    removeStatus(state);
-    appendLiveItem(state, { type: "error", text: e.message });
+    if (!abortCtrl.signal.aborted) {
+      removeStatus(state);
+      appendLiveItem(state, { type: "error", text: e.message });
+    }
   }
 
   if (userItem) delete userItem.meta;
+  setAbortCtrl(null);
   renderScreen();
 }
 
@@ -424,6 +644,14 @@ function handleProgressEvent(event, state, renderScreen) {
     return;
   }
 
+  if (event.type === "model_retry") {
+    const status = [...state.transcript].reverse().find((item) => item?.type === "status" && item?.active);
+    if (status) status.text = "Retrying with tool fallback...";
+    else appendLiveItem(state, { type: "status", text: "Retrying with tool fallback...", active: true });
+    renderScreen();
+    return;
+  }
+
   if (event.type === "assistant_text" && event.text) {
     removeStatus(state);
     appendLiveItem(state, {

package/src/cli/commands/telegram.js

@@ -4,8 +4,14 @@ export async function cmdTelegramSend(args) {
   const text = args._[0];
   if (!text) throw new Error("apx telegram send: missing <text>");
   const chat_id = args.flags.chat === true ? undefined : args.flags.chat;
-  const result = await http.post("/telegram/send", { chat_id, text });
-  console.log(`✅ sent (message_id=${result.message_id})`);
+  // --interrupt / --force: send immediately bypassing any pending agent queue
+  const interrupt = !!(args.flags.interrupt || args.flags.force);
+  const result = await http.post("/telegram/send", { chat_id, text, interrupt });
+  if (interrupt) {
+    console.log(`⚡ sent (interrupt, message_id=${result.message_id})`);
+  } else {
+    console.log(`✅ sent (message_id=${result.message_id})`);
+  }
 }
 
 export async function cmdTelegramStatus() {

package/src/cli/http.js

@@ -75,6 +75,7 @@ async function request(method, path, body, opts = {}) {
     method,
     headers: body ? { "content-type": "application/json" } : {},
     body: body ? JSON.stringify(body) : undefined,
+    signal: opts.signal,
   });
   const text = await res.text();
   let json;
@@ -101,6 +102,7 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
     method,
     headers: body ? { "content-type": "application/json" } : {},
     body: body ? JSON.stringify(body) : undefined,
+    signal: opts.signal,
   });
 
   if (!res.ok) {
@@ -121,10 +123,21 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
   let buffer = "";
   let finalResult = null;
 
+  // Register abort handler to cancel the reader
+  if (opts.signal) {
+    opts.signal.addEventListener("abort", () => reader.cancel().catch(() => {}), { once: true });
+  }
+
   while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
+    let chunk;
+    try {
+      chunk = await reader.read();
+    } catch (e) {
+      // AbortError or cancel — treat as clean end
+      break;
+    }
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
     const lines = buffer.split(/\r?\n/);
     buffer = lines.pop() || "";
     for (const line of lines) {
@@ -138,10 +151,12 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
 
   buffer += decoder.decode();
   if (buffer.trim()) {
-    const event = JSON.parse(buffer);
-    if (event.type === "final") finalResult = event.result;
-    if (event.type === "error") throw new Error(event.error || "stream error");
-    await onEvent?.(event);
+    try {
+      const event = JSON.parse(buffer);
+      if (event.type === "final") finalResult = event.result;
+      if (event.type === "error") throw new Error(event.error || "stream error");
+      await onEvent?.(event);
+    } catch {}
   }
 
   return finalResult;
@@ -156,4 +171,6 @@ export const http = {
   delete: (p, opts) => request("DELETE", p, undefined, opts),
   baseUrl,
   ping,
+  /** Create a fresh AbortController for cancelling in-flight requests. */
+  createAbortController: () => new AbortController(),
 };

package/src/cli/index.js

@@ -607,9 +607,16 @@ const HELP_TOPICS = new Map(Object.entries({
   "telegram send": topic({
     title: "apx telegram send",
     summary: "Send a Telegram message through the configured bridge.",
-    usage: ["apx telegram send \"<text>\" [--chat <id>]"],
-    options: [["--chat <id>", "Override configured chat id."]],
-    examples: ["apx telegram send \"Deploy finished\" --chat 123456"],
+    usage: ["apx telegram send \"<text>\" [--chat <id>] [--interrupt]"],
+    options: [
+      ["--chat <id>", "Override configured chat id."],
+      ["--interrupt", "Send immediately, bypassing any pending agent queue (alias: --force)."],
+      ["--force", "Alias for --interrupt."],
+    ],
+    examples: [
+      "apx telegram send \"Deploy finished\" --chat 123456",
+      "apx telegram send \"Urgent!\" --interrupt",
+    ],
   }),
   "telegram status": topic({
     title: "apx telegram status",

package/src/cli/postinstall.js

@@ -1,10 +1,55 @@
 #!/usr/bin/env node
-// Runs automatically after `npm install -g apx`.
-// Installs APX + APC context skills to all global skill directories.
-import { installGlobalSkills } from "../core/scaffold.js";
+// Runs automatically after `npm install -g apx` and `npm update -g apx`.
+//
+// Two-step process:
+//   1. Refresh the bundled `apc-context` skill from the canonical APC repo.
+//      APC is a living standard — we always want the latest copy at install
+//      time. If the network call fails, the bundled snapshot that ships
+//      with the npm tarball is used.
+//   2. Propagate APX + APC skills (+ runtime docs) into every global skill
+//      directory (~/.claude/skills, ~/.cursor/skills, ~/.codex/skills,
+//      ~/.agents/skills).
+import fs from "node:fs";
+import path from "node:path";
 import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { installGlobalSkills } from "../core/scaffold.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+const APC_SKILL_LOCAL = path.join(PACKAGE_ROOT, "skills", "apc-context", "SKILL.md");
+const APC_SKILL_REMOTE =
+  "https://raw.githubusercontent.com/agentprojectcontext/agentprojectcontext/main/skills/apc-context/SKILL.md";
+
+async function refreshApcSkill() {
+  if (process.env.APX_SKIP_SKILL_REFRESH) return { status: "skipped" };
+
+  try {
+    const fetchImpl = globalThis.fetch || (await import("node-fetch")).default;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 5000);
+
+    const res = await fetchImpl(APC_SKILL_REMOTE, { signal: ac.signal });
+    clearTimeout(timer);
+
+    if (!res.ok) return { status: "fallback", reason: `HTTP ${res.status}` };
+    const text = await res.text();
+
+    if (!text.startsWith("---") || !/name:\s*apc-context/.test(text)) {
+      return { status: "fallback", reason: "remote payload not a SKILL.md" };
+    }
+
+    fs.mkdirSync(path.dirname(APC_SKILL_LOCAL), { recursive: true });
+    fs.writeFileSync(APC_SKILL_LOCAL, text, "utf8");
+    return { status: "refreshed" };
+  } catch (err) {
+    return { status: "fallback", reason: err?.message || String(err) };
+  }
+}
 
 try {
+  const refresh = await refreshApcSkill();
+
   const results = installGlobalSkills();
   if (results.length === 0) process.exit(0);
 
@@ -19,7 +64,12 @@ try {
   for (const [skill, dirs] of Object.entries(bySkill)) {
     console.log(`  ${skill.padEnd(14)} → ${dirs.join(", ")}`);
   }
+  if (refresh.status === "refreshed") {
+    console.log("  apc-context refreshed from agentprojectcontext/agentprojectcontext@main");
+  } else if (refresh.status === "fallback") {
+    console.log(`  apc-context: using bundled snapshot (${refresh.reason})`);
+  }
   console.log("");
 } catch {
-  // Non-fatal — don't break the install
+  // Non-fatal — don't break the install.
 }

package/src/cli/terminal-chat/renderer.js

@@ -173,6 +173,12 @@ function renderPromptBlock(state, chatWidth) {
   const hotkeys =
     C.bold + C.text + "tab" + C.normal + C.muted + " agents  " +
     C.bold + C.text + "ctrl+p" + C.normal + C.muted + " commands  " +
+    (state.hasStarted && state.transcript?.some((t) => t.type === "user" && t.meta === "queued")
+      ? C.bold + C.warning + "ctrl+i" + C.normal + C.muted + " interrupt  "
+      : "") +
+    (state.hasStarted && state.transcript?.length > 0
+      ? C.bold + C.text + "click" + C.normal + C.muted + " actions  "
+      : "") +
     C.bold + C.text + "enter" + C.normal + C.muted + " send";
   const hotkeyLeft = Math.max(left, left + boxWidth - visible(hotkeys));
   writeAt(top + 5, hotkeyLeft, hotkeys, visible(hotkeys), C.bg);
@@ -276,7 +282,11 @@ function transcriptLines(transcript, width) {
         addLine(lines, margin + C.primary + "┃" + C.panel + " " + C.text + padAnsi(chunk, inner), C.bg);
       }
       if (item.meta) {
-        addLine(lines, margin + C.primary + "┃" + C.panel + " " + C.muted + padAnsi(item.meta, inner), C.bg);
+        // Show QUEUED badge with distinct highlight color
+        const badgeText = item.meta === "queued"
+          ? C.warning + C.bold + "QUEUED" + C.normal + C.muted + "  click to send/remove"
+          : C.muted + item.meta;
+        addLine(lines, margin + C.primary + "┃" + C.panel + " " + badgeText + padAnsi("", Math.max(0, inner - (item.meta === "queued" ? 28 : visible(item.meta)))), C.bg);
       }
       addLine(lines, margin + C.primary + "┃" + C.panel + " " + " ".repeat(inner), C.bg);
       continue;
@@ -301,7 +311,23 @@ function transcriptLines(transcript, width) {
     }
 
     if (item.type === "tool") {
-      addToolBlock(lines, item, width);
+      const trace = item.trace || {};
+      const isQuestion = trace.tool === "ask_questions";
+      const label = isQuestion ? C.warning + C.bold + "QUESTION" : C.muted + "TOOL";
+      const name = isQuestion ? "" : C.text + trace.tool;
+      
+      if (isQuestion && trace.args?.questions) {
+        addLine(lines, "", C.bg);
+        addLine(lines, margin + label + C.muted + " (…)" + C.bg, C.bg);
+        for (const q of trace.args.questions) {
+          const qWrapped = wrapText(`• ${q}`, inner - 2);
+          for (const line of qWrapped) {
+            addLine(lines, margin + C.primary + "┃ " + C.text + padAnsi(line, inner - 2), C.bg);
+          }
+        }
+      } else {
+        addLine(lines, margin + label + " " + name + C.bg, C.bg);
+      }
       continue;
     }
 
@@ -408,6 +434,36 @@ function renderPaletteOverlay(state) {
   );
 }
 
+function renderMsgActionsOverlay(state) {
+  const { width, height } = terminalSize();
+  const title = "Message Actions";
+  const opts = state.msgActionsOptions;
+  const preview = fit(state.msgActionsTarget?.text || "", 42);
+  const boxWidth = Math.min(62, Math.max(title.length + 8, preview.length + 6, ...opts.map((x) => visible(x) + 8)));
+  const boxHeight = opts.length + 5;
+  const left = centerLeft(width, boxWidth);
+  const top = Math.max(1, Math.floor((height - boxHeight) / 2));
+
+  writeAt(top, left, C.text + C.bold + " " + title + C.normal, boxWidth, C.panel);
+  writeAt(top + 1, left, C.muted + " " + C.italic + preview + C.noItalic, boxWidth, C.panel);
+  writeAt(top + 2, left, C.dim + "▀".repeat(boxWidth), boxWidth, C.panel);
+  for (let i = 0; i < opts.length; i++) {
+    const active = i === state.msgActionsSelection;
+    const marker = active ? "›" : " ";
+    const bg = active ? C.panel2 : C.panel;
+    const fg = active ? C.primary + C.bold : C.text;
+    writeAt(top + 3 + i, left, fg + ` ${marker} ${opts[i]}` + C.normal, boxWidth, bg);
+  }
+  writeAt(top + 3 + opts.length, left, C.dim + "▄".repeat(boxWidth), boxWidth, C.panel);
+  writeAt(
+    top + 4 + opts.length,
+    left,
+    C.muted + "↑↓ select  " + C.text + C.bold + "enter" + C.normal + C.muted + " choose  " + C.text + C.bold + "esc" + C.normal + C.muted + " close",
+    boxWidth,
+    C.bg
+  );
+}
+
 export function renderTerminalChat(state) {
   clearFull();
   const { width, height } = terminalSize();
@@ -424,5 +480,6 @@ export function renderTerminalChat(state) {
   const cursor = renderPromptBlock(state, chatWidth);
 
   if (state.inCommandPalette) renderPaletteOverlay(state);
-  if (!state.inCommandPalette) moveTo(cursor.row, cursor.col);
+  if (state.inMsgActions) renderMsgActionsOverlay(state);
+  if (!state.inCommandPalette && !state.inMsgActions) moveTo(cursor.row, cursor.col);
 }