@calltelemetry/openclaw-linear 0.9.18 → 0.9.20

package/README.md

@@ -41,7 +41,9 @@ Connect Linear to AI agents. Issues get triaged, implemented, and audited — au
 - [x] CI + coverage badges (1170+ tests, Codecov integration)
 - [x] Setup wizard (`openclaw openclaw-linear setup`) + `doctor --fix` auto-repair
 - [x] Project context auto-detection (repo, framework, build/test commands → worker/audit prompts)
-- [x] Per-backend CLI tools (`cli_codex`, `cli_claude`, `cli_gemini`) with Linear session activity streaming
+- [x] Per-backend CLI tools (`cli_codex`, `cli_claude`, `cli_gemini`) with `[Codex]`/`[Claude]`/`[Gemini]`-prefixed Linear session activity streaming
+- [x] Immediate thought emission on comment receipt and tool dispatch (visible before long-running tasks complete)
+- [x] Proactive OAuth token refresh timer (runs on startup, then every 6h)
 - [ ] **Worktree → PR merge** — `createPullRequest()` exists but is not wired into the pipeline. After audit pass, commits sit on a `codex/{identifier}` branch. You create the PR manually.
 - [ ] **Sub-agent worktree sharing** — Sub-agents spawned via `spawn_agent`/`ask_agent` do not inherit the parent worktree. They run in their own session without code access.
 - [ ] **Parallel worktree conflict resolution** — DAG dispatch runs up to 3 issues concurrently in separate worktrees, but there's no merge conflict detection across them.
@@ -118,7 +120,7 @@ The end result: you work in Linear. You create issues, assign them, comment in p
 
 ### Multi-Backend & Multi-Repo
 
-- **Three coding backends** — Codex (OpenAI), Claude (Anthropic), Gemini (Google). Configurable globally or per-agent. Each backend registers as a dedicated tool (`cli_codex`, `cli_claude`, `cli_gemini`) so agents and Linear session UI show exactly which backend is running. Per-agent overrides let you assign different backends to different team members.
+- **Three coding backends** — Codex (OpenAI), Claude (Anthropic), Gemini (Google). Configurable globally or per-agent. Each backend registers as a dedicated tool (`cli_codex`, `cli_claude`, `cli_gemini`) with `[Codex]`/`[Claude]`/`[Gemini]`-prefixed activity streaming — thoughts, actions, progress, and results all show the backend label in Linear's session UI so you always know which runner is active. Per-agent overrides let you assign different backends to different team members.
 - **Multi-repo dispatch** — Tag an issue with `<!-- repos: api, frontend -->` and the worker gets isolated worktrees for each repo. One issue, multiple codebases, one agent session.
 
 ### Operations
@@ -1303,7 +1305,7 @@ Every agent session gets these registered tools. They're available as native too
 
 ### `cli_codex` / `cli_claude` / `cli_gemini` — Coding backend tools
 
-Three per-backend tools that send tasks to their respective coding CLIs. Each agent sees only the tool matching its configured backend (e.g., an agent configured for `codex` gets `cli_codex`). The tool name is visible in Linear's agent session UI, so you always know which backend is running. The agent writes the prompt; the plugin handles worktree setup, session activity streaming, and output capture.
+Three per-backend tools that send tasks to their respective coding CLIs. Each agent sees only the tool matching its configured backend (e.g., an agent configured for `codex` gets `cli_codex`). All activity emissions are prefixed with the backend label (`[Codex]`, `[Claude]`, `[Gemini]`) — thoughts, action starts, progress updates, results, and errors — so the Linear session UI always shows which runner is active. When a CLI tool is dispatched, an immediate thought is emitted with the prompt excerpt before the long-running task begins. The agent writes the prompt; the plugin handles worktree setup, session activity streaming, and output capture.
 
 ### `linear_issues` — Native Linear API
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.9.18",
+  "version": "0.9.20",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",

package/src/agent/agent.ts

@@ -293,6 +293,8 @@ async function runEmbedded(
 
   // Track last emitted tool to avoid duplicates
   let lastToolAction = "";
+  // Derive a friendly label from cli_ tool names: cli_codex→"Codex", cli_claude→"Claude"
+  const cliLabel = (name: string) => name.startsWith("cli_") ? name.slice(4).charAt(0).toUpperCase() + name.slice(5) : name;
 
   watchdog.start();
 
@@ -335,7 +337,8 @@ async function runEmbedded(
       if (text) {
         // Truncate tool results for activity display
         const truncated = text.length > 300 ? text.slice(0, 300) + "..." : text;
-        emit({ type: "action", action: lastToolAction || "Tool result", parameter: truncated });
+        const prefix = lastToolAction.startsWith("cli_") ? `[${cliLabel(lastToolAction)}] ` : "";
+        emit({ type: "action", action: `${prefix}${lastToolAction || "Tool result"}`, parameter: truncated });
       }
     },
 
@@ -364,11 +367,14 @@ async function runEmbedded(
       if (phase === "start") {
         lastToolAction = toolName;
 
-        // cli_codex / cli_claude / cli_gemini: show working dir and prompt excerpt
+        // cli_codex / cli_claude / cli_gemini: emit a thought + action so the
+        // user immediately sees what the agent is dispatching and why.
         if (toolName.startsWith("cli_") && inputObj) {
+          const tag = cliLabel(toolName);
           const prompt = String(inputObj.prompt ?? "").slice(0, 250);
           const workDir = inputObj.workingDir ? ` in ${inputObj.workingDir}` : "";
-          emit({ type: "action", action: `Running ${toolName}${workDir}`, parameter: prompt });
+          emit({ type: "thought", body: `[${tag}] Starting${workDir}: "${prompt}"\n\n${toolName}\nin progress` });
+          emit({ type: "action", action: `[${tag}] Running${workDir}`, parameter: prompt });
         } else {
           const detail = input || meta || toolName;
           emit({ type: "action", action: `Running ${toolName}`, parameter: detail.slice(0, 300) });
@@ -378,18 +384,21 @@ async function runEmbedded(
       // Tool execution update — partial progress (keeps Linear UI alive for long tools)
       if (phase === "update") {
         const detail = meta || input || "in progress";
-        emit({ type: "action", action: `${toolName}`, parameter: detail.slice(0, 300) });
+        const prefix = toolName.startsWith("cli_") ? `[${cliLabel(toolName)}] ` : "";
+        emit({ type: "action", action: `${prefix}${toolName}`, parameter: detail.slice(0, 300) });
       }
 
       // Tool execution completed successfully
       if (phase === "result" && !data.isError) {
         const detail = meta ? meta.slice(0, 300) : "completed";
-        emit({ type: "action", action: `${toolName} done`, parameter: detail });
+        const prefix = toolName.startsWith("cli_") ? `[${cliLabel(toolName)}] ` : "";
+        emit({ type: "action", action: `${prefix}${toolName} done`, parameter: detail });
       }
 
       // Tool execution result with error
       if (phase === "result" && data.isError) {
-        emit({ type: "action", action: `${toolName} failed`, parameter: (meta || "error").slice(0, 300) });
+        const prefix = toolName.startsWith("cli_") ? `[${cliLabel(toolName)}] ` : "";
+        emit({ type: "action", action: `${prefix}${toolName} failed`, parameter: (meta || "error").slice(0, 300) });
       }
     },
 

package/src/infra/tmux-runner.ts

@@ -1,6 +1,6 @@
 import { execSync, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-import { mkdirSync, createWriteStream } from "node:fs";
+import { mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import type { ActivityContent, LinearAgentApi } from "../api/linear-api.js";
 import type { CliResult, OnProgressUpdate } from "../tools/cli-shared.js";
@@ -45,8 +45,12 @@ export function getActiveTmuxSession(issueId: string): TmuxSession | null {
 }
 
 /**
- * Run a command inside a tmux session with pipe-pane streaming to a JSONL log.
+ * Run a command inside a tmux session with output piped to a JSONL log.
  * Monitors the log file for events and streams them to Linear.
+ *
+ * The command + tee are wrapped in a shell script so that tee runs INSIDE
+ * the tmux session (not in the outer shell). This ensures JSONL output
+ * from the CLI subprocess is captured to the log file.
  */
 export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
   const {
@@ -70,6 +74,9 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
   // Ensure log directory exists
   mkdirSync(dirname(logPath), { recursive: true });
 
+  // Touch the log file so tail -f can start immediately
+  writeFileSync(logPath, "", { flag: "a" });
+
   // Register active session
   const session: TmuxSession = {
     sessionName,
@@ -83,14 +90,25 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
   const progress = createProgressEmitter({ header: progressHeader, onUpdate });
   progress.emitHeader();
 
+  // Write a shell wrapper script so the entire pipeline (command | tee)
+  // runs inside the tmux session. This avoids quoting hell and ensures
+  // tee captures the subprocess output, not tmux's own stdout.
+  const scriptPath = `${logPath}.run.sh`;
+
   try {
-    // Create tmux session running the command, piping output to logPath
-    const tmuxCmd = [
-      `tmux new-session -d -s ${shellEscape(sessionName)} -c ${shellEscape(cwd)}`,
-      `${shellEscape(command)} 2>&1 | tee ${shellEscape(logPath)}`,
-    ].join(" ");
+    writeFileSync(scriptPath, [
+      "#!/bin/sh",
+      `exec ${command} 2>&1 | tee -a ${shellEscape(logPath)}`,
+      "",
+    ].join("\n"), { mode: 0o755 });
 
-    execSync(tmuxCmd, { stdio: "ignore", timeout: 10_000 });
+    // Start tmux session running the wrapper script
+    execSync(
+      `tmux new-session -d -s ${shellEscape(sessionName)} -c ${shellEscape(cwd)} ${shellEscape(scriptPath)}`,
+      { stdio: "ignore", timeout: 10_000 },
+    );
+
+    logger.info(`tmux session started: ${sessionName} (log: ${logPath})`);
 
     // Tail the log file and process JSONL events
     return await new Promise<CliResult>((resolve) => {
@@ -100,6 +118,8 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
 
       let killed = false;
       let killedByWatchdog = false;
+      let resolved = false;
+      let completionEventReceived = false;
       const collectedMessages: string[] = [];
 
       const timer = setTimeout(() => {
@@ -120,6 +140,9 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
       watchdog.start();
 
       function cleanup(reason: string) {
+        if (resolved) return;
+        resolved = true;
+
         clearTimeout(timer);
         watchdog.stop();
         tail.kill();
@@ -132,6 +155,9 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
           });
         } catch { /* session may already be gone */ }
 
+        // Clean up wrapper script
+        try { unlinkSync(scriptPath); } catch { /* best effort */ }
+
         activeSessions.delete(issueId);
 
         const output = collectedMessages.join("\n\n") || "(no output)";
@@ -150,8 +176,15 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
             output: `Agent timed out after ${Math.round(timeoutMs / 1000)}s. Partial output:\n${output}`,
             error: "timeout",
           });
+        } else if (reason === "unexpected_exit") {
+          logger.warn(`tmux session ${sessionName} exited without completion event`);
+          resolve({
+            success: false,
+            output: `Agent session exited unexpectedly (no completion event received). Partial output:\n${output}`,
+            error: "unexpected_exit",
+          });
         } else {
-          // Normal completion
+          // Normal completion — only reached when completionEventReceived is true
           resolve({ success: true, output });
         }
       }
@@ -169,8 +202,9 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
           return;
         }
 
-        // Collect text for output
+        // Collect text for output — handle both Claude and Codex event shapes
         if (event.type === "assistant") {
+          // Claude stream-json shape
           const content = event.message?.content;
           if (Array.isArray(content)) {
             for (const block of content) {
@@ -180,6 +214,11 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
             }
           }
         }
+        if (event.item?.type === "agent_message" || event.item?.type === "message") {
+          // Codex --json shape
+          const text = event.item.text ?? event.item.content ?? "";
+          if (text) collectedMessages.push(text);
+        }
 
         // Stream to Linear
         const activity = mapEvent(event);
@@ -192,28 +231,39 @@ export async function runInTmux(opts: RunInTmuxOptions): Promise<CliResult> {
           progress.push(formatActivityLogLine(activity));
         }
 
-        // Detect completion
-        if (event.type === "result") {
+        // Detect completion — Claude uses "result", Codex uses "session.completed"
+        if (event.type === "result" || event.type === "session.completed") {
+          completionEventReceived = true;
           cleanup("done");
           rl.close();
         }
       });
 
-      // Handle tail process ending (tmux session completed)
+      // Handle tail process ending (tmux session exited)
       tail.on("close", () => {
-        if (!killed) {
-          cleanup("done");
+        if (!resolved) {
+          // If we never saw a completion event, the session died unexpectedly
+          if (completionEventReceived) {
+            cleanup("done");
+          } else {
+            cleanup("unexpected_exit");
+          }
         }
         rl.close();
       });
 
       tail.on("error", (err) => {
         logger.error(`tmux tail error: ${err}`);
-        cleanup("error");
+        if (!resolved) {
+          cleanup("error");
+        }
         rl.close();
       });
     });
   } catch (err) {
+    // Clean up wrapper script on failure
+    try { unlinkSync(scriptPath); } catch { /* best effort */ }
+
     activeSessions.delete(issueId);
     logger.error(`runInTmux failed: ${err}`);
     return {

package/src/pipeline/webhook.ts

@@ -1731,11 +1731,12 @@ async function dispatchCommentToAgent(
       });
     }
 
-    // Emit thought
+    // Emit thought — include comment excerpt so the user sees immediate context
     if (agentSessionId) {
+      const excerpt = commentBody.length > 200 ? commentBody.slice(0, 200) + "..." : commentBody;
       await linearApi.emitActivity(agentSessionId, {
         type: "thought",
-        body: `${label} is processing comment on ${issueRef}...`,
+        body: `${label} received comment on ${issueRef}: "${excerpt}" — working on it now...`,
       }).catch(() => {});
     }