feat: stream all content blocks as activities to Linear

Event mappers now return ActivityContent[] instead of single items.
For Claude, assistant messages with both text and tool_use blocks now
emit separate activities for each — previously only the first block
was returned, dropping whichever came second. Codex and Gemini mappers
updated for consistent interface (no behavioral change since their
events are one-activity-per-event).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: calltelemetry-jason

src/infra/tmux-runner.ts

@@ -33,7 +33,7 @@ export interface RunInTmuxOptions {
   timeoutMs: number;
   watchdogMs: number;
   logPath: string;
-  mapEvent: (event: any) => ActivityContent | null;
+  mapEvent: (event: any) => ActivityContent[];
   linearApi?: LinearAgentApi;
   agentSessionId?: string;
   steeringMode: "stdin-pipe" | "one-shot";
@@ -247,8 +247,8 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
         }
 
         // Stream to Linear
-        const activity = mapEvent(event);
-        if (activity) {
+        const activities = mapEvent(event);
+        for (const activity of activities) {
           if (linearApi && agentSessionId) {
             linearApi.emitActivity(agentSessionId, activity).catch((err) => {
               logger.warn(`Failed to emit tmux activity: ${err}`);

src/tools/claude-tool.ts

@@ -26,17 +26,18 @@ const CLAUDE_BIN = "claude";
  * Claude event types:
  *   system(init) → assistant (text|tool_use) → user (tool_result) → result
  */
-function mapClaudeEventToActivity(event: any): ActivityContent | null {
+function mapClaudeEventToActivity(event: any): ActivityContent[] {
   const type = event?.type;
 
-  // Assistant message — text response or tool use
+  // Assistant message — text response and/or tool use (emit all blocks)
   if (type === "assistant") {
     const content = event.message?.content;
-    if (!Array.isArray(content)) return null;
+    if (!Array.isArray(content)) return [];
 
+    const activities: ActivityContent[] = [];
     for (const block of content) {
       if (block.type === "text" && block.text) {
-        return { type: "thought", body: block.text.slice(0, 1000) };
+        activities.push({ type: "thought", body: block.text.slice(0, 1000) });
       }
       if (block.type === "tool_use") {
         const toolName = block.name ?? "tool";
@@ -54,30 +55,31 @@ function mapClaudeEventToActivity(event: any): ActivityContent | null {
         } else {
           paramSummary = JSON.stringify(input).slice(0, 500);
         }
-        return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+        activities.push({ type: "action", action: `Running ${toolName}`, parameter: paramSummary });
       }
     }
-    return null;
+    return activities;
   }
 
   // Tool result
   if (type === "user") {
     const content = event.message?.content;
-    if (!Array.isArray(content)) return null;
+    if (!Array.isArray(content)) return [];
 
+    const activities: ActivityContent[] = [];
     for (const block of content) {
       if (block.type === "tool_result") {
         const output = typeof block.content === "string" ? block.content : "";
         const truncated = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
         const isError = block.is_error === true;
-        return {
+        activities.push({
           type: "action",
           action: isError ? "Tool error" : "Tool result",
           parameter: truncated || "(no output)",
-        };
+        });
       }
     }
-    return null;
+    return activities;
   }
 
   // Final result
@@ -92,10 +94,10 @@ function mapClaudeEventToActivity(event: any): ActivityContent | null {
       const output = usage.output_tokens ?? 0;
       parts.push(`${input} in / ${output} out tokens`);
     }
-    return { type: "thought", body: parts.join(" — ") };
+    return [{ type: "thought", body: parts.join(" — ") }];
   }
 
-  return null;
+  return [];
 }
 
 /**
@@ -299,9 +301,9 @@ export async function runClaude(
         // (it duplicates the last assistant text message)
       }
 
-      // Stream activity to Linear + session progress
-      const activity = mapClaudeEventToActivity(event);
-      if (activity) {
+      // Stream activities to Linear + session progress
+      const activities = mapClaudeEventToActivity(event);
+      for (const activity of activities) {
         if (linearApi && agentSessionId) {
           linearApi.emitActivity(agentSessionId, activity).catch((err) => {
             api.logger.warn(`Failed to emit Claude activity: ${err}`);

src/tools/codex-tool.ts

@@ -23,30 +23,30 @@ const CODEX_BIN = "codex";
 /**
  * Parse a JSONL line from `codex exec --json` and map it to a Linear activity.
  */
-function mapCodexEventToActivity(event: any): ActivityContent | null {
+function mapCodexEventToActivity(event: any): ActivityContent[] {
   const eventType = event?.type;
   const item = event?.item;
 
   if (item?.type === "reasoning") {
     const text = item.text ?? "";
-    return { type: "thought", body: text ? text.slice(0, 500) : "Reasoning..." };
+    return [{ type: "thought", body: text ? text.slice(0, 500) : "Reasoning..." }];
   }
 
   if (
     (eventType === "item.completed" || eventType === "item.started") &&
     (item?.type === "agent_message" || item?.type === "message")
   ) {
     const text = item.text ?? item.content ?? "";
-    if (text) return { type: "thought", body: text.slice(0, 1000) };
-    return null;
+    if (text) return [{ type: "thought", body: text.slice(0, 1000) }];
+    return [];
   }
 
   if (eventType === "item.started" && item?.type === "command_execution") {
     const cmd = item.command ?? "unknown";
     const cleaned = typeof cmd === "string"
       ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
       : JSON.stringify(cmd);
-    return { type: "action", action: "Running", parameter: cleaned.slice(0, 200) };
+    return [{ type: "action", action: "Running", parameter: cleaned.slice(0, 200) }];
   }
 
   if (eventType === "item.completed" && item?.type === "command_execution") {
@@ -57,19 +57,19 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
       ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
       : JSON.stringify(cmd);
     const truncated = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
-    return {
+    return [{
       type: "action",
       action: `${cleaned.slice(0, 150)}`,
       parameter: `exit ${exitCode}`,
       result: truncated || undefined,
-    };
+    }];
   }
 
   if (eventType === "item.completed" && item?.type === "file_changes") {
     const files = item.files ?? [];
     const fileList = Array.isArray(files) ? files.join(", ") : String(files);
     const preview = (item.diff ?? item.content ?? "").slice(0, 500) || undefined;
-    return { type: "action", action: "Modified files", parameter: fileList || "unknown files", result: preview };
+    return [{ type: "action", action: "Modified files", parameter: fileList || "unknown files", result: preview }];
   }
 
   if (eventType === "turn.completed") {
@@ -78,12 +78,12 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
       const input = usage.input_tokens ?? 0;
       const cached = usage.cached_input_tokens ?? 0;
       const output = usage.output_tokens ?? 0;
-      return { type: "thought", body: `Codex turn complete (${input} in / ${cached} cached / ${output} out tokens)` };
+      return [{ type: "thought", body: `Codex turn complete (${input} in / ${cached} cached / ${output} out tokens)` }];
     }
-    return { type: "thought", body: "Codex turn complete" };
+    return [{ type: "thought", body: "Codex turn complete" }];
   }
 
-  return null;
+  return [];
 }
 
 /**
@@ -248,8 +248,8 @@ export async function runCodex(
         collectedCommands.push(`\`${cleanCmd}\` → exit ${exitCode}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`);
       }
 
-      const activity = mapCodexEventToActivity(event);
-      if (activity) {
+      const activities = mapCodexEventToActivity(event);
+      for (const activity of activities) {
         if (linearApi && agentSessionId) {
           linearApi.emitActivity(agentSessionId, activity).catch((err) => {
             api.logger.warn(`Failed to emit Codex activity: ${err}`);

src/tools/gemini-tool.ts

@@ -26,14 +26,14 @@ const GEMINI_BIN = "gemini";
  * Gemini event types:
  *   init → message(user) → message(assistant) → tool_use → tool_result → result
  */
-function mapGeminiEventToActivity(event: any): ActivityContent | null {
+function mapGeminiEventToActivity(event: any): ActivityContent[] {
   const type = event?.type;
 
   // Assistant message (delta text)
   if (type === "message" && event.role === "assistant") {
     const text = event.content;
-    if (text) return { type: "thought", body: text.slice(0, 1000) };
-    return null;
+    if (text) return [{ type: "thought", body: text.slice(0, 1000) }];
+    return [];
   }
 
   // Tool use — running a command or tool
@@ -50,19 +50,19 @@ function mapGeminiEventToActivity(event: any): ActivityContent | null {
     } else {
       paramSummary = JSON.stringify(params).slice(0, 500);
     }
-    return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+    return [{ type: "action", action: `Running ${toolName}`, parameter: paramSummary }];
   }
 
   // Tool result
   if (type === "tool_result") {
     const status = event.status ?? "unknown";
     const output = event.output ?? "";
     const truncated = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
-    return {
+    return [{
       type: "action",
       action: `Tool ${status}`,
       parameter: truncated || "(no output)",
-    };
+    }];
   }
 
   // Final result
@@ -74,10 +74,10 @@ function mapGeminiEventToActivity(event: any): ActivityContent | null {
       if (stats.total_tokens) parts.push(`${stats.total_tokens} tokens`);
       if (stats.tool_calls) parts.push(`${stats.tool_calls} tool calls`);
     }
-    return { type: "thought", body: parts.join(" — ") };
+    return [{ type: "thought", body: parts.join(" — ") }];
   }
 
-  return null;
+  return [];
 }
 
 /**
@@ -244,9 +244,9 @@ export async function runGemini(
         }
       }
 
-      // Stream activity to Linear + session progress
-      const activity = mapGeminiEventToActivity(event);
-      if (activity) {
+      // Stream activities to Linear + session progress
+      const activities = mapGeminiEventToActivity(event);
+      for (const activity of activities) {
         if (linearApi && agentSessionId) {
           linearApi.emitActivity(agentSessionId, activity).catch((err) => {
             api.logger.warn(`Failed to emit Gemini activity: ${err}`);