@calltelemetry/openclaw-linear 0.9.21 → 0.9.23

package/index.ts

@@ -1,7 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi, PluginHookAgentEndEvent, PluginHookAgentContext, PluginHookSubagentEndedEvent, PluginHookSubagentContext, PluginHookSessionStartEvent, PluginHookSessionEndEvent, PluginHookSessionContext, PluginHookAfterCompactionEvent, PluginHookBeforeResetEvent } from "openclaw/plugin-sdk";
 import { registerLinearProvider } from "./src/api/auth.js";
 import { registerCli } from "./src/infra/cli.js";
 import { createLinearTools } from "./src/tools/tools.js";
@@ -20,7 +20,6 @@ import { createDispatchHistoryTool } from "./src/tools/dispatch-history-tool.js"
 import { readDispatchState as readStateForHook, listActiveDispatches as listActiveForHook } from "./src/pipeline/dispatch-state.js";
 import { startTokenRefreshTimer, stopTokenRefreshTimer } from "./src/infra/token-refresh-timer.js";
 
-const COMPLETION_HOOK_NAMES = ["agent_end", "task_completed", "task_completion"] as const;
 const SUCCESS_STATUSES = new Set(["ok", "success", "completed", "complete", "done", "pass", "passed"]);
 const FAILURE_STATUSES = new Set(["error", "failed", "failure", "timeout", "timed_out", "cancelled", "canceled", "aborted", "unknown"]);
 
@@ -66,7 +65,7 @@ function extractCompletionOutput(event: any): string {
 }
 
 export default function register(api: OpenClawPluginApi) {
-  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const pluginConfig = api.pluginConfig;
 
   // Check token availability (config → env → auth profile store)
   const tokenInfo = resolveLinearToken(pluginConfig);
@@ -102,6 +101,8 @@ export default function register(api: OpenClawPluginApi) {
   // Register Linear webhook handler on a dedicated route
   api.registerHttpRoute({
     path: "/linear/webhook",
+    auth: "plugin",
+    match: "exact",
     handler: async (req, res) => {
       await handleLinearWebhook(api, req, res);
     },
@@ -110,6 +111,8 @@ export default function register(api: OpenClawPluginApi) {
   // Back-compat route so existing production webhook URLs keep working.
   api.registerHttpRoute({
     path: "/hooks/linear",
+    auth: "plugin",
+    match: "exact",
     handler: async (req, res) => {
       await handleLinearWebhook(api, req, res);
     },
@@ -118,6 +121,8 @@ export default function register(api: OpenClawPluginApi) {
   // Register OAuth callback route
   api.registerHttpRoute({
     path: "/linear/oauth/callback",
+    auth: "plugin",
+    match: "exact",
     handler: async (req, res) => {
       await handleOAuthCallback(api, req, res);
     },
@@ -146,110 +151,196 @@ export default function register(api: OpenClawPluginApi) {
   // Instantiate notifier (Discord, Slack, or both — config-driven)
   const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime, api);
 
-  // Register completion hooks — safety net for sessions_spawn sub-agents.
-  // In the current implementation, the worker->audit->verdict flow runs inline
-  // via spawnWorker() in pipeline.ts. These hooks catch sessions_spawn agents
-  // (future upgrade path) and serve as a recovery mechanism.
-  const onAnyHook = api.on as unknown as (hookName: string, handler: (event: any, ctx: any) => Promise<void> | void) => void;
+  // ---------------------------------------------------------------------------
+  // Typed dispatch completion handler (shared by agent_end + subagent_ended)
+  // ---------------------------------------------------------------------------
+  const handleDispatchCompletion = async (
+    sessionKey: string,
+    success: boolean,
+    output: string,
+    hookName: string,
+  ) => {
+    const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+    const state = await readDispatchState(statePath);
+    const mapping = lookupSessionMapping(state, sessionKey);
+    if (!mapping) return; // Not a dispatch sub-agent
+
+    const dispatch = getActiveDispatch(state, mapping.dispatchId);
+    if (!dispatch) {
+      api.logger.info(`${hookName}: dispatch ${mapping.dispatchId} no longer active`);
+      return;
+    }
+
+    // Stale event rejection — only process if attempt matches
+    if (dispatch.attempt !== mapping.attempt) {
+      api.logger.info(
+        `${hookName}: stale event for ${mapping.dispatchId} ` +
+        `(event attempt=${mapping.attempt}, current=${dispatch.attempt})`
+      );
+      return;
+    }
+
+    // Create Linear API for hook context
+    const tokenInfo = resolveLinearToken(pluginConfig);
+    if (!tokenInfo.accessToken) {
+      api.logger.error(`${hookName}: no Linear access token — cannot process dispatch event`);
+      return;
+    }
+    const linearApi = new LinearAgentApi(tokenInfo.accessToken, {
+      refreshToken: tokenInfo.refreshToken,
+      expiresAt: tokenInfo.expiresAt,
+    });
 
-  const handleCompletionEvent = async (event: any, ctx: any, hookName: string) => {
+    const hookCtx: HookContext = {
+      api,
+      linearApi,
+      notify,
+      pluginConfig,
+      configPath: statePath,
+    };
+
+    if (mapping.phase === "worker") {
+      api.logger.info(`${hookName}: worker completed for ${mapping.dispatchId} - triggering audit`);
+      await triggerAudit(hookCtx, dispatch, { success, output }, sessionKey);
+    } else if (mapping.phase === "audit") {
+      api.logger.info(`${hookName}: audit completed for ${mapping.dispatchId} - processing verdict`);
+      await processVerdict(hookCtx, dispatch, { success, output }, sessionKey);
+    }
+  };
+
+  const escalateDispatchError = async (sessionKey: string, err: unknown, hookName: string) => {
     try {
-      const sessionKey = ctx?.sessionKey ?? "";
-      if (!sessionKey) return;
+      const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+      const state = await readDispatchState(statePath);
+      const mapping = sessionKey ? lookupSessionMapping(state, sessionKey) : null;
+      if (mapping) {
+        const dispatch = getActiveDispatch(state, mapping.dispatchId);
+        if (dispatch && dispatch.status !== "done" && dispatch.status !== "stuck" && dispatch.status !== "failed") {
+          const stuckReason = `Hook error: ${err instanceof Error ? err.message : String(err)}`.slice(0, 500);
+          await transitionDispatch(
+            mapping.dispatchId,
+            dispatch.status as DispatchStatus,
+            "stuck",
+            { stuckReason },
+            statePath,
+          );
+          await notify("escalation", {
+            identifier: dispatch.issueIdentifier,
+            title: dispatch.issueTitle ?? "Unknown",
+            status: "stuck",
+            reason: `Dispatch failed in ${mapping.phase} phase: ${stuckReason}`,
+          }).catch(() => {});
+        }
+      }
+    } catch (escalateErr) {
+      api.logger.error(`${hookName} escalation also failed: ${escalateErr}`);
+    }
+  };
+
+  // agent_end — fires when an agent run completes (primary dispatch handler)
+  api.on("agent_end", async (event: PluginHookAgentEndEvent, ctx: PluginHookAgentContext) => {
+    const sessionKey = ctx?.sessionKey ?? "";
+    if (!sessionKey) return;
+    try {
+      const output = extractCompletionOutput(event);
+      const success = parseCompletionSuccess(event);
+      await handleDispatchCompletion(sessionKey, success, output, "agent_end");
+    } catch (err) {
+      api.logger.error(`agent_end hook error: ${err}`);
+      await escalateDispatchError(sessionKey, err, "agent_end");
+    }
+  });
 
+  // subagent_ended — fires when a subagent session ends (proper lifecycle hook, new in 3.7)
+  // This catches sessions_spawn sub-agents with structured outcome data.
+  api.on("subagent_ended", async (event: PluginHookSubagentEndedEvent, ctx: PluginHookSubagentContext) => {
+    const sessionKey = event.targetSessionKey ?? ctx?.childSessionKey ?? "";
+    if (!sessionKey) return;
+    try {
+      const success = event.outcome === "ok";
+      const output = event.error ?? event.reason ?? "";
+      await handleDispatchCompletion(sessionKey, success, output, "subagent_ended");
+    } catch (err) {
+      api.logger.error(`subagent_ended hook error: ${err}`);
+      await escalateDispatchError(sessionKey, err, "subagent_ended");
+    }
+  });
+
+  // session_start — track dispatch session lifecycle
+  api.on("session_start", async (event: PluginHookSessionStartEvent, ctx: PluginHookSessionContext) => {
+    const sessionKey = ctx?.sessionKey ?? event?.sessionKey ?? "";
+    if (!sessionKey) return;
+    try {
       const statePath = pluginConfig?.dispatchStatePath as string | undefined;
       const state = await readDispatchState(statePath);
       const mapping = lookupSessionMapping(state, sessionKey);
-      if (!mapping) return; // Not a dispatch sub-agent
-
-      const dispatch = getActiveDispatch(state, mapping.dispatchId);
-      if (!dispatch) {
-        api.logger.info(`${hookName}: dispatch ${mapping.dispatchId} no longer active`);
-        return;
+      if (mapping) {
+        api.logger.info(`session_start: dispatch ${mapping.dispatchId} phase=${mapping.phase} session started`);
       }
+    } catch {
+      // Never block session start for telemetry
+    }
+  });
 
-      // Stale event rejection — only process if attempt matches
-      if (dispatch.attempt !== mapping.attempt) {
+  // session_end — log dispatch session duration for observability
+  api.on("session_end", async (event: PluginHookSessionEndEvent, ctx: PluginHookSessionContext) => {
+    const sessionKey = ctx?.sessionKey ?? event?.sessionKey ?? "";
+    if (!sessionKey) return;
+    try {
+      const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+      const state = await readDispatchState(statePath);
+      const mapping = lookupSessionMapping(state, sessionKey);
+      if (mapping) {
+        const durationSec = event.durationMs ? Math.round(event.durationMs / 1000) : "?";
         api.logger.info(
-          `${hookName}: stale event for ${mapping.dispatchId} ` +
-          `(event attempt=${mapping.attempt}, current=${dispatch.attempt})`
+          `session_end: dispatch ${mapping.dispatchId} phase=${mapping.phase} ` +
+          `messages=${event.messageCount} duration=${durationSec}s`
         );
-        return;
       }
+    } catch {
+      // Never block session end for telemetry
+    }
+  });
 
-      // Create Linear API for hook context
-      const tokenInfo = resolveLinearToken(pluginConfig);
-      if (!tokenInfo.accessToken) {
-        api.logger.error(`${hookName}: no Linear access token — cannot process dispatch event`);
-        return;
+  // after_compaction — log when dispatch sessions compact (visibility into context pressure)
+  api.on("after_compaction", async (event: PluginHookAfterCompactionEvent, ctx: PluginHookAgentContext) => {
+    const sessionKey = ctx?.sessionKey ?? "";
+    if (!sessionKey) return;
+    try {
+      const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+      const state = await readDispatchState(statePath);
+      const mapping = lookupSessionMapping(state, sessionKey);
+      if (mapping) {
+        api.logger.warn(
+          `after_compaction: dispatch ${mapping.dispatchId} phase=${mapping.phase} ` +
+          `compacted ${event.compactedCount} messages (${event.messageCount} remaining)`
+        );
       }
-      const linearApi = new LinearAgentApi(tokenInfo.accessToken, {
-        refreshToken: tokenInfo.refreshToken,
-        expiresAt: tokenInfo.expiresAt,
-      });
-
-      const hookCtx: HookContext = {
-        api,
-        linearApi,
-        notify,
-        pluginConfig,
-        configPath: statePath,
-      };
-
-      const output = extractCompletionOutput(event);
-      const success = parseCompletionSuccess(event);
+    } catch {
+      // Never block compaction pipeline
+    }
+  });
 
-      if (mapping.phase === "worker") {
-        api.logger.info(`${hookName}: worker completed for ${mapping.dispatchId} - triggering audit`);
-        await triggerAudit(hookCtx, dispatch, {
-          success,
-          output,
-        }, sessionKey);
-      } else if (mapping.phase === "audit") {
-        api.logger.info(`${hookName}: audit completed for ${mapping.dispatchId} - processing verdict`);
-        await processVerdict(hookCtx, dispatch, {
-          success,
-          output,
-        }, sessionKey);
-      }
-    } catch (err) {
-      api.logger.error(`${hookName} hook error: ${err}`);
-      // Escalate: mark dispatch as stuck so it's visible
-      try {
-        const statePath = pluginConfig?.dispatchStatePath as string | undefined;
-        const state = await readDispatchState(statePath);
-        const sessionKey = ctx?.sessionKey ?? "";
-        const mapping = sessionKey ? lookupSessionMapping(state, sessionKey) : null;
-        if (mapping) {
-          const dispatch = getActiveDispatch(state, mapping.dispatchId);
-          if (dispatch && dispatch.status !== "done" && dispatch.status !== "stuck" && dispatch.status !== "failed") {
-            const stuckReason = `Hook error: ${err instanceof Error ? err.message : String(err)}`.slice(0, 500);
-            await transitionDispatch(
-              mapping.dispatchId,
-              dispatch.status as DispatchStatus,
-              "stuck",
-              { stuckReason },
-              statePath,
-            );
-            // Notify if possible
-            await notify("escalation", {
-              identifier: dispatch.issueIdentifier,
-              title: dispatch.issueTitle ?? "Unknown",
-              status: "stuck",
-              reason: `Dispatch failed in ${mapping.phase} phase: ${stuckReason}`,
-            }).catch(() => {}); // Don't fail on notification failure
-          }
-        }
-      } catch (escalateErr) {
-        api.logger.error(`${hookName} escalation also failed: ${escalateErr}`);
+  // before_reset — clean up dispatch tracking when a session is reset
+  api.on("before_reset", async (event: PluginHookBeforeResetEvent, ctx: PluginHookAgentContext) => {
+    const sessionKey = ctx?.sessionKey ?? "";
+    if (!sessionKey) return;
+    try {
+      const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+      const state = await readDispatchState(statePath);
+      const mapping = lookupSessionMapping(state, sessionKey);
+      if (mapping) {
+        api.logger.warn(
+          `before_reset: dispatch ${mapping.dispatchId} phase=${mapping.phase} session reset ` +
+          `(reason: ${event.reason ?? "unknown"})`
+        );
       }
+    } catch {
+      // Never block reset
     }
-  };
+  });
 
-  for (const hookName of COMPLETION_HOOK_NAMES) {
-    onAnyHook(hookName, (event: any, ctx: any) => handleCompletionEvent(event, ctx, hookName));
-  }
-  api.logger.info(`Dispatch completion hooks registered: ${COMPLETION_HOOK_NAMES.join(", ")}`);
+  api.logger.info("Dispatch lifecycle hooks registered: agent_end, subagent_ended, session_start, session_end, after_compaction, before_reset");
 
   // Inject recent dispatch history as context for worker/audit agents
   api.on("before_agent_start", async (event: any, ctx: any) => {
@@ -336,11 +427,11 @@ export default function register(api: OpenClawPluginApi) {
   ];
   const MAX_SHORT_RESPONSE = 250;
 
-  api.on("message_sending", (event: { content?: string }) => {
+  api.on("message_sending", (event) => {
     const text = event?.content ?? "";
-    if (!text || text.length > MAX_SHORT_RESPONSE) return {};
+    if (!text || text.length > MAX_SHORT_RESPONSE) return;
     const isNarration = NARRATION_PATTERNS.some((p) => p.test(text));
-    if (!isNarration) return {};
+    if (!isNarration) return;
     api.logger.warn(`Narration guard triggered: "${text.slice(0, 80)}..."`);
     return {
       content:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.9.21",
+  "version": "0.9.23",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",
@@ -35,7 +35,7 @@
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",
-    "openclaw": "^2026.2.13",
+    "openclaw": "^2026.3.7",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },

package/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}`);

package/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}`);

package/src/tools/codex-tool.ts

@@ -23,13 +23,13 @@ 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 (
@@ -37,8 +37,8 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
     (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") {
@@ -46,7 +46,7 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
     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}`);

package/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,7 +50,7 @@ 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
@@ -58,11 +58,11 @@ function mapGeminiEventToActivity(event: any): ActivityContent | null {
     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}`);