@hienlh/ppm 0.18.1 → 0.18.3

package/src/services/team-member-activity/member-activity.service.ts

@@ -0,0 +1,117 @@
+/**
+ * Per-teammate live activity for the team panel.
+ *
+ * Answers the two questions the inbox cannot: *is anyone working right now*, and
+ * *how far along are they*. Neither is derivable from `~/.claude/teams/<team>/`
+ * — every member there reads "active" forever, because an inbox only records the
+ * task it was handed. The signal lives in the agent transcripts instead: a
+ * transcript being appended to right now is a teammate working right now.
+ */
+
+import { join } from "node:path";
+import { resolveSessionDir } from "../subagent-transcript-merger.ts";
+import { indexTranscriptsByMember, type SubagentTranscriptEntry } from "./subagent-transcript-index.ts";
+import { summarizeTranscriptTail } from "./transcript-tail-summary.ts";
+import { scanOutboundMessages, type OutboundTeamMessage } from "./outbound-message-scanner.ts";
+
+/** A transcript touched within this window means the agent is mid-work. */
+export const WORKING_WINDOW_MS = 90_000;
+
+export type MemberWorkState = "working" | "paused" | "no-transcript";
+
+export interface TeamMemberActivity {
+  name: string;
+  /** `working` while the transcript is being appended to, else `paused`. */
+  workState: MemberWorkState;
+  agentType?: string;
+  model?: string;
+  /** Spawn-time description of the job. */
+  description?: string;
+  /** tool_use id of the spawning Agent call — links to the chat card. */
+  toolUseId?: string;
+  startedAt?: string;
+  lastEventAt?: string;
+  /** Latest tool the agent ran, and its headline argument. */
+  lastTool?: string;
+  lastToolArg?: string;
+  /** Latest prose the agent wrote about its own progress. */
+  lastNarrative?: string;
+  /** Transcript size — a rough "how much work happened" measure. */
+  sizeBytes: number;
+}
+
+/** Locate a team's subagents dir. An implicit team is named after its session. */
+export function resolveTeamSubagentsDir(teamName: string, projectPath?: string | null): string | null {
+  const sessionDir = resolveSessionDir(teamName, projectPath);
+  return sessionDir ? join(sessionDir, "subagents") : null;
+}
+
+function workStateFor(entry: SubagentTranscriptEntry, now: number): MemberWorkState {
+  if (!entry.sizeBytes) return "no-transcript";
+  return now - entry.modifiedAt <= WORKING_WINDOW_MS ? "working" : "paused";
+}
+
+/**
+ * Activity for every teammate that has a transcript, newest work first.
+ *
+ * Only head/tail slices are read per member, so this stays cheap enough to poll
+ * while the panel is open.
+ */
+export async function readTeamMemberActivity(
+  teamName: string,
+  projectPath?: string | null,
+): Promise<TeamMemberActivity[]> {
+  const subagentsDir = resolveTeamSubagentsDir(teamName, projectPath);
+  if (!subagentsDir) return [];
+  const byMember = indexTranscriptsByMember(subagentsDir);
+  const now = Date.now();
+
+  const rows = await Promise.all(
+    [...byMember.entries()].map(async ([name, entry]) => {
+      const tail = await summarizeTranscriptTail(entry.transcriptPath);
+      return {
+        name,
+        workState: workStateFor(entry, now),
+        agentType: entry.agentType,
+        model: entry.model,
+        description: entry.description,
+        toolUseId: entry.toolUseId,
+        sizeBytes: entry.sizeBytes,
+        ...tail,
+      } satisfies TeamMemberActivity;
+    }),
+  );
+
+  // Whoever is working belongs at the top; within a group, most recent first.
+  return rows.sort((a, b) => {
+    if (a.workState !== b.workState) return a.workState === "working" ? -1 : b.workState === "working" ? 1 : 0;
+    return (b.lastEventAt ?? "").localeCompare(a.lastEventAt ?? "");
+  });
+}
+
+/** Every reply teammates sent out, across the team's transcripts. */
+export async function readTeamOutboundMessages(
+  teamName: string,
+  projectPath?: string | null,
+): Promise<OutboundTeamMessage[]> {
+  const subagentsDir = resolveTeamSubagentsDir(teamName, projectPath);
+  if (!subagentsDir) return [];
+  const byMember = indexTranscriptsByMember(subagentsDir);
+  const batches = await Promise.all(
+    [...byMember.entries()].map(([name, entry]) => scanOutboundMessages(entry.transcriptPath, name)),
+  );
+  return batches
+    .flat()
+    .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+}
+
+/** Transcript path for one teammate, or null when it has none. */
+export function resolveMemberTranscript(
+  teamName: string,
+  memberName: string,
+  projectPath?: string | null,
+): string | null {
+  const subagentsDir = resolveTeamSubagentsDir(teamName, projectPath);
+  if (!subagentsDir) return null;
+  return indexTranscriptsByMember(subagentsDir).get(memberName)?.transcriptPath ?? null;
+}

package/src/services/team-member-activity/outbound-message-scanner.ts

@@ -0,0 +1,121 @@
+/**
+ * Recover the replies teammates send back, which the inboxes do not hold.
+ *
+ * A team inbox only ever contains what was sent *to* that handle, and in
+ * practice that is just the lead's task assignments. A teammate's own reports
+ * ("phase 3 done, commit 5344b74", "blocked, need file ownership") are
+ * `SendMessage` tool calls inside its transcript, addressed to the orchestrator.
+ * Reading them here is what turns the activity panel from a one-way task list
+ * into the actual conversation.
+ *
+ * Transcripts are append-only, so each is scanned incrementally: only bytes
+ * added since the last scan are read, which keeps a 6 MB transcript from being
+ * re-parsed on every poll.
+ */
+
+import { open, stat } from "node:fs/promises";
+
+export interface OutboundTeamMessage {
+  /** Teammate handle that sent it. */
+  from: string;
+  /** Recipient as addressed by the agent — often `main` for the orchestrator. */
+  to: string;
+  /** Raw message body; may itself be a JSON protocol payload. */
+  text: string;
+  /** Author-supplied one-line label, when given. */
+  summary?: string;
+  /** ISO timestamp of the record carrying the call. */
+  timestamp: string;
+}
+
+interface ScanState {
+  /** Byte offset of the first unscanned byte. */
+  offset: number;
+  messages: OutboundTeamMessage[];
+}
+
+/** Per-transcript incremental scan state, keyed by absolute path. */
+const scanCache = new Map<string, ScanState>();
+
+const str = (v: unknown): string => (typeof v === "string" ? v : "");
+
+/** Extract SendMessage calls from one transcript record. */
+function collectFromRecord(rec: Record<string, unknown>, from: string, into: OutboundTeamMessage[]): void {
+  const content = (rec.message as Record<string, unknown> | undefined)?.content;
+  if (!Array.isArray(content)) return;
+  const timestamp = str(rec.timestamp);
+  for (const block of content as Record<string, unknown>[]) {
+    if (block?.type !== "tool_use" || block.name !== "SendMessage") continue;
+    const input = (block.input ?? {}) as Record<string, unknown>;
+    // Canonical schema is `{ to, message }`; older team prompts taught
+    // `{ recipient, content }` and agents still emit both shapes.
+    const to = str(input.to) || str(input.recipient);
+    const message = input.message ?? input.content;
+    const text = typeof message === "string" ? message : message == null ? "" : JSON.stringify(message);
+    if (!to && !text) continue;
+    const summary = str(input.summary);
+    into.push({ from, to: to || "main", text, timestamp, ...(summary ? { summary } : {}) });
+  }
+}
+
+/**
+ * Messages a teammate sent out, from its transcript.
+ *
+ * @param path Absolute transcript path.
+ * @param from Teammate handle to attribute the messages to.
+ */
+export async function scanOutboundMessages(path: string, from: string): Promise<OutboundTeamMessage[]> {
+  let size = 0;
+  try {
+    size = (await stat(path)).size;
+  } catch {
+    return [];
+  }
+
+  const cached = scanCache.get(path);
+  // A shrunk file was rewritten, not appended — the cached offset is meaningless.
+  const state: ScanState = cached && cached.offset <= size ? cached : { offset: 0, messages: [] };
+  scanCache.set(path, state);
+  if (state.offset >= size) return state.messages;
+
+  const length = size - state.offset;
+  let handle;
+  try {
+    handle = await open(path, "r");
+  } catch {
+    return state.messages;
+  }
+  let chunk = "";
+  try {
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buf, 0, length, state.offset);
+    chunk = buf.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return state.messages;
+  } finally {
+    await handle.close().catch(() => {});
+  }
+
+  // Advance only past the last complete line; a partial trailing record is
+  // re-read on the next scan once the writer has finished it.
+  const lastNewline = chunk.lastIndexOf("\n");
+  if (lastNewline < 0) return state.messages;
+  const complete = chunk.slice(0, lastNewline);
+  state.offset += Buffer.byteLength(complete, "utf8") + 1;
+
+  for (const line of complete.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes("SendMessage")) continue;
+    try {
+      collectFromRecord(JSON.parse(trimmed), from, state.messages);
+    } catch {
+      /* malformed record */
+    }
+  }
+  return state.messages;
+}
+
+/** Drop cached scan state (used by tests and when a team is deleted). */
+export function clearOutboundScanCache(): void {
+  scanCache.clear();
+}

package/src/services/team-member-activity/subagent-transcript-index.ts

@@ -0,0 +1,95 @@
+/**
+ * Index a session's subagent transcripts by teammate name.
+ *
+ * Claude Code writes one transcript per spawned agent at
+ *   ~/.claude/projects/<slug>/<sessionId>/subagents/agent-<id>.jsonl
+ * with a sibling `agent-<id>.meta.json` carrying `{ agentType, description,
+ * name, toolUseId, model }`. That `name` is the same handle the team inbox uses
+ * (`dev-p1`, `lead`, …), which is what lets a team member be joined to the
+ * transcript of the work it actually did.
+ *
+ * A team's inbox only records the task it was handed; the transcript is the sole
+ * record of what it then did, so this index is the bridge between the two.
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+export interface SubagentTranscriptEntry {
+  /** Teammate handle from the meta file; absent for unnamed one-off agents. */
+  name?: string;
+  /** Registered agent type, e.g. `ak-engineer:fullstack-developer`. */
+  agentType?: string;
+  /** Spawn-time description of the job. */
+  description?: string;
+  /** Model the agent ran on, when the meta records one. */
+  model?: string;
+  /** tool_use id of the spawning Agent call — links back to the chat card. */
+  toolUseId?: string;
+  /** Absolute path of the agent's JSONL transcript. */
+  transcriptPath: string;
+  /** Transcript size in bytes — the cheap "how much work" signal. */
+  sizeBytes: number;
+  /** Last write time in epoch ms — the cheap "is it still running" signal. */
+  modifiedAt: number;
+}
+
+/** Read every `*.meta.json` in a subagents dir, paired with its transcript. */
+export function listSubagentTranscripts(subagentsDir: string): SubagentTranscriptEntry[] {
+  let entries: string[];
+  try {
+    entries = readdirSync(subagentsDir);
+  } catch {
+    return []; // no subagents dir — session never spawned an agent
+  }
+
+  const out: SubagentTranscriptEntry[] = [];
+  for (const file of entries) {
+    if (!file.endsWith(".meta.json")) continue;
+    const transcriptPath = join(subagentsDir, file.replace(/\.meta\.json$/, ".jsonl"));
+    if (!existsSync(transcriptPath)) continue;
+    let meta: Record<string, unknown> = {};
+    try {
+      meta = JSON.parse(readFileSync(join(subagentsDir, file), "utf8"));
+    } catch {
+      /* unreadable meta — still surface the transcript, just unlabelled */
+    }
+    let sizeBytes = 0;
+    let modifiedAt = 0;
+    try {
+      const st = statSync(transcriptPath);
+      sizeBytes = st.size;
+      modifiedAt = st.mtimeMs;
+    } catch {
+      /* raced with a delete — treat as empty */
+    }
+    out.push({
+      name: typeof meta.name === "string" ? meta.name : undefined,
+      agentType: typeof meta.agentType === "string" ? meta.agentType : undefined,
+      description: typeof meta.description === "string" ? meta.description : undefined,
+      model: typeof meta.model === "string" ? meta.model : undefined,
+      toolUseId: typeof meta.toolUseId === "string" ? meta.toolUseId : undefined,
+      transcriptPath,
+      sizeBytes,
+      modifiedAt,
+    });
+  }
+  return out;
+}
+
+/**
+ * Newest transcript per teammate name.
+ *
+ * A retried teammate reuses its handle (`dev-p8`, then `dev-p8b`), but a plain
+ * re-spawn under the same name would collide — the most recently written
+ * transcript is the one describing current work, so it wins.
+ */
+export function indexTranscriptsByMember(subagentsDir: string): Map<string, SubagentTranscriptEntry> {
+  const byName = new Map<string, SubagentTranscriptEntry>();
+  for (const entry of listSubagentTranscripts(subagentsDir)) {
+    if (!entry.name) continue;
+    const existing = byName.get(entry.name);
+    if (!existing || entry.modifiedAt > existing.modifiedAt) byName.set(entry.name, entry);
+  }
+  return byName;
+}

package/src/services/team-member-activity/transcript-tail-summary.ts

@@ -0,0 +1,125 @@
+/**
+ * "What is this agent doing right now" from a transcript, without reading it all.
+ *
+ * A single teammate transcript reaches 6 MB, and a team has ~25 of them. The
+ * members list is polled while the panel is open, so a full parse per poll would
+ * read tens of MB every few seconds. Only the head (for the start time) and a
+ * bounded tail (for the latest activity) are read here; the full transcript is
+ * parsed lazily, and only for the one member whose window is open.
+ */
+
+import { open, stat } from "node:fs/promises";
+
+/** Tail budget. Big enough to hold several records, small enough to stay cheap. */
+const TAIL_BYTES = 256 * 1024;
+/** Head budget — the first record carries the earliest timestamp. */
+const HEAD_BYTES = 64 * 1024;
+
+export interface TranscriptTailSummary {
+  /** ISO timestamp of the transcript's first record. */
+  startedAt?: string;
+  /** ISO timestamp of the most recent record. */
+  lastEventAt?: string;
+  /** Most recent tool the agent invoked, e.g. `PowerShell`. */
+  lastTool?: string;
+  /** Compact argument of that tool call — command, path or pattern. */
+  lastToolArg?: string;
+  /** Most recent prose the agent wrote about what it is doing. */
+  lastNarrative?: string;
+}
+
+/** Read a byte range as utf-8, tolerating a short or missing file. */
+async function readRange(path: string, start: number, length: number): Promise<string> {
+  if (length <= 0) return "";
+  let handle;
+  try {
+    handle = await open(path, "r");
+  } catch {
+    return "";
+  }
+  try {
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buf, 0, length, start);
+    return buf.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
+/** Parse whole JSONL lines out of a possibly-truncated chunk. */
+function parseRecords(chunk: string, dropFirstPartial: boolean): Record<string, unknown>[] {
+  const lines = chunk.split("\n");
+  // A mid-file read almost always starts inside a record — that fragment is not JSON.
+  if (dropFirstPartial) lines.shift();
+  const out: Record<string, unknown>[] = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      /* truncated tail record or mid-write line */
+    }
+  }
+  return out;
+}
+
+/** The most informative single argument of a tool call, for a one-line preview. */
+function toolArg(input: unknown): string | undefined {
+  if (!input || typeof input !== "object") return undefined;
+  const i = input as Record<string, unknown>;
+  for (const key of ["command", "file_path", "path", "pattern", "description", "prompt", "url"]) {
+    const v = i[key];
+    if (typeof v === "string" && v.trim()) {
+      // Multi-line commands are common; the first line identifies the action.
+      return v.trim().split("\n")[0]!.slice(0, 160);
+    }
+  }
+  return undefined;
+}
+
+/** Pull the latest tool call and prose out of records in stream order. */
+function summarizeRecords(records: Record<string, unknown>[], into: TranscriptTailSummary): void {
+  for (const rec of records) {
+    const ts = rec.timestamp;
+    if (typeof ts === "string") into.lastEventAt = ts;
+    const content = (rec.message as Record<string, unknown> | undefined)?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content as Record<string, unknown>[]) {
+      if (block?.type === "tool_use" && typeof block.name === "string") {
+        into.lastTool = block.name;
+        into.lastToolArg = toolArg(block.input);
+      } else if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) {
+        into.lastNarrative = block.text.trim().split("\n")[0]!.slice(0, 200);
+      }
+    }
+  }
+}
+
+/** Latest activity in a transcript, reading only its head and tail. */
+export async function summarizeTranscriptTail(path: string): Promise<TranscriptTailSummary> {
+  let size = 0;
+  try {
+    size = (await stat(path)).size;
+  } catch {
+    return {};
+  }
+  const summary: TranscriptTailSummary = {};
+
+  const head = parseRecords(await readRange(path, 0, Math.min(HEAD_BYTES, size)), false);
+  const firstTs = head.find((r) => typeof r.timestamp === "string")?.timestamp;
+  if (typeof firstTs === "string") summary.startedAt = firstTs;
+
+  // When the file fits in one read, head already holds everything.
+  if (size <= HEAD_BYTES) {
+    summarizeRecords(head, summary);
+    return summary;
+  }
+
+  const tailStart = Math.max(0, size - TAIL_BYTES);
+  const tail = parseRecords(await readRange(path, tailStart, size - tailStart), tailStart > 0);
+  summarizeRecords(tail, summary);
+  return summary;
+}

package/src/shared/background-agent-status.ts

@@ -0,0 +1,79 @@
+/**
+ * Lifecycle of a backgrounded subagent (`Agent`/`Task` with `run_in_background`).
+ *
+ * The tool call itself returns the instant the agent is spawned — its result is a launch
+ * acknowledgement, not a report. The agent then runs past the end of the turn and only
+ * reports back through a `<task-notification>` the CLI injects as a user message.
+ *
+ * A tool card that treats the launch ack as "finished" therefore shows a green check while
+ * the agent is still working and its step count keeps climbing. Everything here exists so
+ * both the transcript loader and the live stream can tell the two apart.
+ */
+
+import type { ChatEvent, ChatMessage } from "../types/chat";
+
+/** Terminal states the CLI reports for a background task. */
+export type BackgroundAgentStatus = "completed" | "failed" | "stopped";
+
+/** Text the Agent/Task tool returns when it only spawned the agent. */
+const LAUNCH_ACK = "Async agent launched successfully";
+
+/**
+ * Whether an Agent/Task tool result is a launch acknowledgement rather than the agent's
+ * report. Keyed off the result text, not `input.run_in_background`: that flag is optional
+ * (backgrounding is the default) and absent from most recorded calls, whereas the ack text
+ * is emitted for every async launch and never for a synchronous one.
+ */
+export function isAsyncAgentLaunchAck(output: string | undefined): boolean {
+  return !!output && output.includes(LAUNCH_ACK);
+}
+
+const NOTIFICATION_RE = /<task-notification>([\s\S]*?)<\/task-notification>/g;
+
+/** Terminal statuses reported by `<task-notification>` blocks, keyed by Agent tool_use id. */
+export function parseTaskNotifications(content: string): Map<string, BackgroundAgentStatus> {
+  const out = new Map<string, BackgroundAgentStatus>();
+  if (!content.includes("<task-notification>")) return out;
+  for (const [, body] of content.matchAll(NOTIFICATION_RE)) {
+    const toolUseId = body!.match(/<tool-use-id>([\s\S]*?)<\/tool-use-id>/)?.[1]?.trim();
+    const status = body!.match(/<status>([\s\S]*?)<\/status>/)?.[1]?.trim();
+    // Orphan-scan summaries carry task ids but no tool-use-id — nothing to attach them to.
+    if (!toolUseId || !isTerminalAgentStatus(status)) continue;
+    out.set(toolUseId, status);
+  }
+  return out;
+}
+
+/** Whether a CLI-reported task status means the agent has stopped running for good. */
+export function isTerminalAgentStatus(v: string | undefined): v is BackgroundAgentStatus {
+  return v === "completed" || v === "failed" || v === "stopped";
+}
+
+/**
+ * Stamp `bgStatus` onto every backgrounded Agent/Task tool_use in a loaded transcript.
+ *
+ * Notifications land in user messages that come after — sometimes many turns after — the
+ * message holding the tool call, so this has to run across the whole transcript rather than
+ * per message. Agents with no notification yet are left unstamped: the card reads that as
+ * still running.
+ */
+export function applyBackgroundAgentStatus(messages: ChatMessage[]): void {
+  const statuses = new Map<string, BackgroundAgentStatus>();
+  for (const msg of messages) {
+    if (msg.role !== "user" || !msg.content) continue;
+    for (const [id, status] of parseTaskNotifications(msg.content)) statuses.set(id, status);
+  }
+  if (statuses.size === 0) return;
+
+  for (const msg of messages) {
+    for (const ev of msg.events ?? []) {
+      if (!isSubagentToolUse(ev) || !ev.toolUseId) continue;
+      const status = statuses.get(ev.toolUseId);
+      if (status) ev.bgStatus = status;
+    }
+  }
+}
+
+function isSubagentToolUse(ev: ChatEvent): ev is Extract<ChatEvent, { type: "tool_use" }> {
+  return ev.type === "tool_use" && (ev.tool === "Agent" || ev.tool === "Task");
+}

package/src/types/api.ts

@@ -63,6 +63,7 @@ export type ChatWsServerMessage =
   | { type: "tool_result"; output: string; isError?: boolean; toolUseId?: string; parentToolUseId?: string }
   | { type: "bash_output"; toolUseId: string; content: string; lineCount: number }
   | { type: "background_registry"; sessionId: string; shells: BackgroundShell[] }
+  | { type: "subagent_status"; toolUseId: string; status: import("../shared/background-agent-status").BackgroundAgentStatus }
   | { type: "approval_request"; requestId: string; tool: string; input: unknown }
   | { type: "done"; sessionId: string; contextWindowPct?: number }
   | { type: "error"; message: string }

package/src/types/chat.ts

@@ -158,7 +158,12 @@ export type ResultSubtype =
 export type ChatEvent =
   | { type: "text"; content: string; parentToolUseId?: string }
   | { type: "thinking"; content: string; parentToolUseId?: string }
-  | { type: "tool_use"; tool: string; input: unknown; toolUseId?: string; parentToolUseId?: string; children?: ChatEvent[] }
+  | {
+      type: "tool_use"; tool: string; input: unknown; toolUseId?: string; parentToolUseId?: string; children?: ChatEvent[];
+      /** Terminal state of a backgrounded Agent/Task, once its `<task-notification>` arrives.
+       *  Absent on a launched-but-unfinished agent — the card renders that as still running. */
+      bgStatus?: import("../shared/background-agent-status").BackgroundAgentStatus;
+    }
   | { type: "tool_result"; output: string; isError?: boolean; toolUseId?: string; parentToolUseId?: string }
   | { type: "approval_request"; requestId: string; tool: string; input: unknown }
   | { type: "error"; message: string }

package/src/web/components/chat/chat-history-bar.tsx

@@ -598,12 +598,14 @@ export function ChatHistoryBar({
         </div>
       )}
 
-      {/* Team activity panel */}
+      {/* Team activity panel — its tabs each scroll on their own, so no outer scroll */}
       {activePanel === "team" && teamActivity?.hasTeams && (
-        <div className="border-t border-border/30 bg-surface px-3 py-2 max-h-[280px] overflow-y-auto">
+        <div className="border-t border-border/30 bg-surface px-3 py-2">
           <TeamActivityPanel
             teamNames={teamActivity.teamNames}
             messages={teamMessages ?? []}
+            sessionId={sessionId}
+            projectName={projectName}
           />
         </div>
       )}

package/src/web/components/chat/chat-tab.tsx

@@ -696,6 +696,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
         {/* Input — gate on first draft load to avoid empty→filled flash, then keep mounted */}
         {(inputReady || !draftLoading) && (
           <MessageInput
+            tabId={tabId}
             onSend={handleInputSend}
             isStreaming={isStreaming}
             onCancel={cancelStreaming}

package/src/web/components/chat/message-input.tsx

@@ -4,6 +4,7 @@ import { useVoiceInput } from "@/hooks/use-voice-input";
 import { api, projectUrl, getAuthToken } from "@/lib/api-client";
 import { randomId } from "@/lib/utils";
 import { ownsGlobalShortcut } from "@/lib/owns-global-shortcut";
+import { SEND_TO_CHAT_EVENT, SEND_TO_CHAT_ACK_EVENT, type SendToChatDetail } from "@/lib/send-to-chat";
 import { isImageFile } from "@/lib/file-support";
 import { AttachmentChips } from "./attachment-chips";
 import { stepHistory } from "./message-history-recall";
@@ -32,6 +33,8 @@ export interface ChatAttachment {
 export type MessagePriority = 'now' | 'next' | 'later';
 
 interface MessageInputProps {
+  /** Tab id of the owning chat tab — addresses "Send to Chat" at this tab only. */
+  tabId?: string;
   onSend: (content: string, attachments: ChatAttachment[], priority?: MessagePriority) => void;
   isStreaming?: boolean;
   onCancel?: () => void;
@@ -86,6 +89,7 @@ interface MessageInputProps {
 }
 
 export const MessageInput = memo(function MessageInput({
+  tabId,
   onSend,
   isStreaming,
   onCancel,
@@ -231,12 +235,15 @@ export const MessageInput = memo(function MessageInput({
     return () => window.removeEventListener("toggle-voice-input", handler);
   }, [voice.supported, handleVoiceToggle, getVisibleTextarea]);
 
-  // Listen for "Send to Chat" from terminal or other tabs — add as attachment chip
+  // "Send to Chat" (terminal output, other tabs) — add as an attachment chip.
+  // Every chat tab stays mounted, so the event is addressed: only the tab it names
+  // may consume it, or the same output lands in every open chat at once.
   useEffect(() => {
     const handler = (e: Event) => {
-      const { text, label } = (e as CustomEvent).detail ?? {};
+      const { text, label, targetTabId } = ((e as CustomEvent).detail ?? {}) as SendToChatDetail;
       if (!text) return;
-      window.dispatchEvent(new Event("ppm:send-to-chat:ack"));
+      if (targetTabId ? targetTabId !== tabId : !ownsGlobalShortcut(getVisibleTextarea())) return;
+      window.dispatchEvent(new Event(SEND_TO_CHAT_ACK_EVENT));
       const att: ChatAttachment = {
         id: randomId(),
         name: label ?? "Terminal output",
@@ -248,9 +255,9 @@ export const MessageInput = memo(function MessageInput({
       setAttachments((prev) => [...prev, att]);
       getVisibleTextarea()?.focus();
     };
-    window.addEventListener("ppm:send-to-chat", handler);
-    return () => window.removeEventListener("ppm:send-to-chat", handler);
-  }, [getVisibleTextarea]);
+    window.addEventListener(SEND_TO_CHAT_EVENT, handler);
+    return () => window.removeEventListener(SEND_TO_CHAT_EVENT, handler);
+  }, [getVisibleTextarea, tabId]);
 
   // Apply initialValue when it changes (e.g. "Ask AI" from command palette).
   // A restored draft can land after the input is already on screen, so never

package/src/web/components/chat/mini-markdown.tsx

@@ -0,0 +1,17 @@
+import { lazy, Suspense } from "react";
+
+const MarkdownRenderer = lazy(() =>
+  import("@/components/shared/markdown-renderer").then((m) => ({ default: m.MarkdownRenderer }))
+);
+
+/**
+ * Compact, height-capped markdown for tool cards. Lazy so the markdown bundle only
+ * loads once a card is actually expanded.
+ */
+export function MiniMarkdown({ content, maxHeight = "max-h-48" }: { content: string; maxHeight?: string }) {
+  return (
+    <Suspense fallback={<div className="animate-pulse h-4 bg-muted rounded" />}>
+      <MarkdownRenderer content={content} className={`text-text-secondary overflow-auto ${maxHeight}`} />
+    </Suspense>
+  );
+}