@calltelemetry/openclaw-linear 0.9.15 → 0.9.16

package/src/tools/cli-shared.ts

@@ -14,6 +14,7 @@ export interface CliToolParams {
   workingDir?: string;
   model?: string;
   timeoutMs?: number;
+  issueId?: string;
   issueIdentifier?: string;
   agentSessionId?: string;
 }
@@ -24,6 +25,51 @@ export interface CliResult {
   error?: string;
 }
 
+export type OnProgressUpdate = (update: Record<string, unknown>) => void;
+
+/**
+ * Format a Linear activity as a single streaming log line for session progress.
+ */
+export function formatActivityLogLine(activity: { type: string; body?: string; action?: string; parameter?: string; result?: string }): string {
+  if (activity.type === "thought") {
+    return `▸ ${(activity.body ?? "").slice(0, 300)}`;
+  }
+  if (activity.type === "action") {
+    const result = activity.result ? `\n  → ${activity.result.slice(0, 200)}` : "";
+    return `▸ ${activity.action ?? ""}: ${(activity.parameter ?? "").slice(0, 300)}${result}`;
+  }
+  return `▸ ${JSON.stringify(activity).slice(0, 300)}`;
+}
+
+/**
+ * Create a progress emitter that maintains a rolling log of streaming events.
+ * Calls onUpdate with the full accumulated log on each new event.
+ */
+export function createProgressEmitter(opts: {
+  header: string;
+  onUpdate?: OnProgressUpdate;
+  maxLines?: number;
+}): { push: (line: string) => void; emitHeader: () => void } {
+  const lines: string[] = [];
+  const maxLines = opts.maxLines ?? 40;
+  const { header, onUpdate } = opts;
+
+  function emit() {
+    if (!onUpdate) return;
+    const log = lines.length > 0 ? "\n---\n" + lines.join("\n") : "";
+    try { onUpdate({ status: "running", summary: header + log }); } catch {}
+  }
+
+  return {
+    emitHeader() { emit(); },
+    push(line: string) {
+      lines.push(line);
+      if (lines.length > maxLines) lines.splice(0, lines.length - maxLines);
+      emit();
+    },
+  };
+}
+
 /**
  * Build a LinearAgentApi instance for streaming activities to Linear.
  */
@@ -53,9 +99,10 @@ export function buildLinearApi(
  */
 export function resolveSession(params: CliToolParams): {
   agentSessionId: string | undefined;
+  issueId: string | undefined;
   issueIdentifier: string | undefined;
 } {
-  let { issueIdentifier, agentSessionId } = params;
+  let { issueId, issueIdentifier, agentSessionId } = params;
 
   if (!agentSessionId || !issueIdentifier) {
     const active = issueIdentifier
@@ -63,11 +110,12 @@ export function resolveSession(params: CliToolParams): {
       : getCurrentSession();
     if (active) {
       agentSessionId = agentSessionId ?? active.agentSessionId;
+      issueId = issueId ?? active.issueId;
       issueIdentifier = issueIdentifier ?? active.issueIdentifier;
     }
   }
 
-  return { agentSessionId, issueIdentifier };
+  return { agentSessionId, issueId, issueIdentifier };
 }
 
 /**

package/src/tools/code-tool.ts

@@ -1,39 +1,64 @@
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { AnyAgentTool, OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
 import { jsonResult } from "openclaw/plugin-sdk";
-import { getCurrentSession } from "../pipeline/active-session.js";
+import { getCurrentSession, getActiveSessionByAgentId } from "../pipeline/active-session.js";
 import { runCodex } from "./codex-tool.js";
 import { runClaude } from "./claude-tool.js";
 import { runGemini } from "./gemini-tool.js";
-import type { CliToolParams, CliResult } from "./cli-shared.js";
+import type { CliToolParams, CliResult, OnProgressUpdate } from "./cli-shared.js";
+import { DEFAULT_BASE_REPO } from "./cli-shared.js";
 
 export type CodingBackend = "claude" | "codex" | "gemini";
 
-const BACKEND_LABELS: Record<CodingBackend, string> = {
-  claude: "Claude Code (Anthropic)",
-  codex: "Codex (OpenAI)",
-  gemini: "Gemini CLI (Google)",
-};
-
-const BACKEND_RUNNERS: Record<
-  CodingBackend,
-  (api: OpenClawPluginApi, params: CliToolParams, pluginConfig?: Record<string, unknown>) => Promise<CliResult>
-> = {
-  claude: runClaude,
-  codex: runCodex,
-  gemini: runGemini,
+const BACKENDS: Record<CodingBackend, {
+  label: string;
+  toolName: string;
+  runner: (api: OpenClawPluginApi, params: CliToolParams, pluginConfig?: Record<string, unknown>, onUpdate?: OnProgressUpdate) => Promise<CliResult>;
+  description: string;
+  configKeyTimeout: string;
+  configKeyBaseRepo: string;
+}> = {
+  codex: {
+    label: "Codex CLI (OpenAI)",
+    toolName: "cli_codex",
+    runner: runCodex,
+    description:
+      "Run OpenAI Codex CLI to perform a coding task. " +
+      "Can read/write files, run commands, search code, run tests. " +
+      "Streams progress to Linear in real-time.",
+    configKeyTimeout: "codexTimeoutMs",
+    configKeyBaseRepo: "codexBaseRepo",
+  },
+  claude: {
+    label: "Claude Code (Anthropic)",
+    toolName: "cli_claude",
+    runner: runClaude,
+    description:
+      "Run Anthropic Claude Code CLI to perform a coding task. " +
+      "Can read/write files, run commands, search code, run tests. " +
+      "Streams progress to Linear in real-time.",
+    configKeyTimeout: "claudeTimeoutMs",
+    configKeyBaseRepo: "claudeBaseRepo",
+  },
+  gemini: {
+    label: "Gemini CLI (Google)",
+    toolName: "cli_gemini",
+    runner: runGemini,
+    description:
+      "Run Google Gemini CLI to perform a coding task. " +
+      "Can read/write files, run commands, search code, run tests. " +
+      "Streams progress to Linear in real-time.",
+    configKeyTimeout: "geminiTimeoutMs",
+    configKeyBaseRepo: "geminiBaseRepo",
+  },
 };
 
-interface BackendConfig {
-  aliases?: string[];
-}
-
 export interface CodingToolsConfig {
   codingTool?: string;
   agentCodingTools?: Record<string, string>;
-  backends?: Record<string, BackendConfig>;
+  backends?: Record<string, { aliases?: string[] }>;
 }
 
 /**
@@ -42,7 +67,6 @@ export interface CodingToolsConfig {
  */
 export function loadCodingConfig(): CodingToolsConfig {
   try {
-    // Resolve relative to the plugin root (one level up from src/)
     const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
     const raw = readFileSync(join(pluginRoot, "coding-tools.json"), "utf8");
     return JSON.parse(raw) as CodingToolsConfig;
@@ -51,37 +75,6 @@ export function loadCodingConfig(): CodingToolsConfig {
   }
 }
 
-/**
- * Build a reverse lookup map: alias (lowercase) → backend ID.
- * Backend IDs themselves are always valid aliases.
- */
-function buildAliasMap(config: CodingToolsConfig): Map<string, CodingBackend> {
-  const map = new Map<string, CodingBackend>();
-
-  for (const backendId of Object.keys(BACKEND_RUNNERS) as CodingBackend[]) {
-    // The backend ID itself is always an alias
-    map.set(backendId, backendId);
-
-    // Add configured aliases
-    const aliases = config.backends?.[backendId]?.aliases;
-    if (aliases) {
-      for (const alias of aliases) {
-        map.set(alias.toLowerCase(), backendId);
-      }
-    }
-  }
-
-  return map;
-}
-
-/**
- * Resolve a user-provided alias string to a backend ID.
- * Returns undefined if no match.
- */
-function resolveAlias(aliasMap: Map<string, CodingBackend>, input: string): CodingBackend | undefined {
-  return aliasMap.get(input.toLowerCase());
-}
-
 /**
  * Resolve which coding backend to use for a given agent.
  *
@@ -94,121 +87,208 @@ export function resolveCodingBackend(
   config: CodingToolsConfig,
   agentId?: string,
 ): CodingBackend {
-  // Per-agent override
   if (agentId) {
     const override = config.agentCodingTools?.[agentId];
-    if (override && override in BACKEND_RUNNERS) return override as CodingBackend;
+    if (override && override in BACKENDS) return override as CodingBackend;
   }
-
-  // Global default
   const global = config.codingTool;
-  if (global && global in BACKEND_RUNNERS) return global as CodingBackend;
-
+  if (global && global in BACKENDS) return global as CodingBackend;
   return "codex";
 }
 
 /**
- * Create the unified `code_run` tool.
+ * Resolve the tool name (cli_codex, cli_claude, cli_gemini) for a given agent.
+ */
+export function resolveToolName(config: CodingToolsConfig, agentId?: string): string {
+  return BACKENDS[resolveCodingBackend(config, agentId)].toolName;
+}
+
+/**
+ * Parse a session key to extract channel routing info for progress messages.
+ */
+function parseChannelTarget(sessionKey?: string): {
+  provider: string;
+  peerId: string;
+} | null {
+  if (!sessionKey) return null;
+  const parts = sessionKey.split(":");
+  if (parts.length < 5 || parts[0] !== "agent") return null;
+  const provider = parts[2];
+  const kind = parts[3];
+  if (!provider || !kind) return null;
+  const peerId = parts[4];
+  if (!peerId) return null;
+  return { provider, peerId };
+}
+
+/**
+ * Create a channel sender that can send messages to the session's channel.
+ */
+function createChannelSender(
+  api: OpenClawPluginApi,
+  sessionKey?: string,
+): ((text: string) => Promise<void>) | null {
+  const target = parseChannelTarget(sessionKey);
+  if (!target) return null;
+  const { provider, peerId } = target;
+
+  if (provider === "discord") {
+    return async (text: string) => {
+      try {
+        await api.runtime.channel.discord.sendMessageDiscord(peerId, text, { silent: true });
+      } catch (err) {
+        api.logger.warn(`cli channel send (discord) failed: ${err}`);
+      }
+    };
+  }
+  if (provider === "telegram") {
+    return async (text: string) => {
+      try {
+        await api.runtime.channel.telegram.sendMessageTelegram(peerId, text, { silent: true });
+      } catch (err) {
+        api.logger.warn(`cli channel send (telegram) failed: ${err}`);
+      }
+    };
+  }
+  return null;
+}
+
+/**
+ * Inject Linear session info into tool params so backend runners can emit
+ * activities to the correct Linear agent session.
+ */
+function injectSessionInfo(
+  params: CliToolParams,
+  ctx: OpenClawPluginToolContext,
+): void {
+  const ctxAgentId = ctx.agentId;
+  const activeSession = getCurrentSession()
+    ?? (ctxAgentId ? getActiveSessionByAgentId(ctxAgentId) : null);
+
+  if (activeSession) {
+    if (!params.agentSessionId) (params as any).agentSessionId = activeSession.agentSessionId;
+    if (!params.issueId) (params as any).issueId = activeSession.issueId;
+    if (!params.issueIdentifier) (params as any).issueIdentifier = activeSession.issueIdentifier;
+  }
+}
+
+/**
+ * Create the three coding CLI tools: cli_codex, cli_claude, cli_gemini.
  *
- * The tool dispatches to the backend configured in coding-tools.json
- * (codingTool / agentCodingTools). The agent always calls `code_run` —
- * it doesn't need to know which CLI is being used.
+ * Each tool directly invokes its backend CLI. The tool name shown in Linear
+ * reflects which CLI is running (e.g. "Running cli_codex").
  */
-export function createCodeTool(
+export function createCodeTools(
   api: OpenClawPluginApi,
-  _ctx: Record<string, unknown>,
-): AnyAgentTool {
+  rawCtx: Record<string, unknown>,
+): AnyAgentTool[] {
+  const ctx = rawCtx as OpenClawPluginToolContext;
   const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
   const codingConfig = loadCodingConfig();
-  const aliasMap = buildAliasMap(codingConfig);
 
-  // Resolve the default backend for the tool description (may be overridden at runtime per-agent)
-  const defaultBackend = resolveCodingBackend(codingConfig);
-  const defaultLabel = BACKEND_LABELS[defaultBackend];
+  const tools: AnyAgentTool[] = [];
 
-  // Build alias description for each backend so the LLM knows what names to use
-  const aliasDescParts: string[] = [];
-  for (const backendId of Object.keys(BACKEND_RUNNERS) as CodingBackend[]) {
-    const aliases = codingConfig.backends?.[backendId]?.aliases ?? [backendId];
-    aliasDescParts.push(`${BACKEND_LABELS[backendId]}: ${aliases.map(a => `"${a}"`).join(", ")}`);
-  }
-  const aliasDesc = aliasDescParts.join("; ");
+  for (const [backendId, backend] of Object.entries(BACKENDS) as [CodingBackend, typeof BACKENDS[CodingBackend]][]) {
+    const tool: AnyAgentTool = {
+      name: backend.toolName,
+      label: backend.label,
+      description: backend.description,
+      parameters: {
+        type: "object",
+        properties: {
+          prompt: {
+            type: "string",
+            description:
+              "What the coding agent should do. Be specific: include file paths, function names, " +
+              "expected behavior, and test requirements.",
+          },
+          workingDir: {
+            type: "string",
+            description: "Override working directory (default: ~/ai-workspace).",
+          },
+          model: {
+            type: "string",
+            description: "Model override for the coding backend.",
+          },
+          timeoutMs: {
+            type: "number",
+            description: "Max runtime in milliseconds (default: 600000 = 10 min).",
+          },
+        },
+        required: ["prompt"],
+      },
+      execute: async (toolCallId: string, params: CliToolParams, ...rest: unknown[]) => {
+        const originalOnUpdate = typeof rest[1] === "function"
+          ? rest[1] as (update: Record<string, unknown>) => void
+          : undefined;
 
-  api.logger.info(`code_run: default backend=${defaultBackend}, aliases=${JSON.stringify(Object.fromEntries(aliasMap))}, per-agent overrides=${JSON.stringify(codingConfig.agentCodingTools ?? {})}`);
+        // Inject Linear session context
+        injectSessionInfo(params, ctx);
 
-  return {
-    name: "code_run",
-    label: "Run Coding Agent",
-    description:
-      `Run an agentic coding CLI to perform a hands-on coding task. ` +
-      `Default backend: ${defaultLabel}. You can override with the 'backend' parameter ` +
-      `if the user asks for a specific tool. ` +
-      `Known aliases — ${aliasDesc}. ` +
-      `The CLI can read/write files, run commands, search code, run tests, and more. ` +
-      `Streams progress to Linear in real-time. Use this for writing code, debugging, ` +
-      `refactoring, creating files, running tests, and other hands-on development work.`,
-    parameters: {
-      type: "object",
-      properties: {
-        prompt: {
-          type: "string",
-          description:
-            "What the coding agent should do. Be specific: include file paths, function names, " +
-            "expected behavior, and test requirements.",
-        },
-        backend: {
-          type: "string",
-          description:
-            `Which coding CLI to use. Accepts any known alias: ${aliasDesc}. ` +
-            "If omitted, uses the configured default.",
-        },
-        workingDir: {
-          type: "string",
-          description: "Override working directory (default: ~/ai-workspace).",
-        },
-        model: {
-          type: "string",
-          description: "Model override for the coding backend.",
-        },
-        timeoutMs: {
-          type: "number",
-          description: "Max runtime in milliseconds (default: 600000 = 10 min).",
-        },
+        const workingDir = params.workingDir
+          ?? (pluginConfig?.[backend.configKeyBaseRepo] as string)
+          ?? DEFAULT_BASE_REPO;
+        const prompt = params.prompt ?? "";
+
+        api.logger.info(`${backend.toolName}: agent=${ctx.agentId ?? "unknown"} dir=${workingDir}`);
+        api.logger.info(`${backend.toolName} prompt: ${prompt.slice(0, 200)}`);
+
+        // Channel progress messaging
+        const channelSend = createChannelSender(api, ctx.sessionKey);
+        if (channelSend) {
+          const initMsg = [
+            `**${backend.toolName}** — ${backend.label}`,
+            `\`${workingDir}\``,
+            `> ${prompt.slice(0, 800)}${prompt.length > 800 ? "..." : ""}`,
+          ].join("\n");
+          channelSend(initMsg).catch(() => {});
+        }
+
+        // Throttled progress forwarding
+        let lastForwardMs = 0;
+        let lastChannelMs = 0;
+        const FORWARD_THROTTLE_MS = 30_000;
+        const CHANNEL_THROTTLE_MS = 20_000;
+
+        const wrappedOnUpdate: OnProgressUpdate = (update) => {
+          const now = Date.now();
+          if (originalOnUpdate && now - lastForwardMs >= FORWARD_THROTTLE_MS) {
+            lastForwardMs = now;
+            try { originalOnUpdate(update); } catch {}
+          }
+          if (channelSend && now - lastChannelMs >= CHANNEL_THROTTLE_MS) {
+            lastChannelMs = now;
+            const summary = String(update.summary ?? "");
+            if (summary) {
+              const logIdx = summary.indexOf("\n---\n");
+              const logPart = logIdx >= 0 ? summary.slice(logIdx + 5) : "";
+              if (logPart.trim()) {
+                const tail = logPart.length > 1200 ? "..." + logPart.slice(-1200) : logPart;
+                channelSend(`\`\`\`\n${tail}\n\`\`\``).catch(() => {});
+              }
+            }
+          }
+        };
+
+        const result = await backend.runner(api, params, pluginConfig, wrappedOnUpdate);
+
+        return jsonResult({
+          success: result.success,
+          backend: backendId,
+          output: result.output,
+          ...(result.error ? { error: result.error } : {}),
+        });
       },
-      required: ["prompt"],
-    },
-    execute: async (toolCallId: string, params: CliToolParams & { backend?: string }, ...rest: unknown[]) => {
-      // Extract onUpdate callback for progress reporting to Linear
-      const onUpdate = typeof rest[1] === "function"
-        ? rest[1] as (update: Record<string, unknown>) => void
-        : undefined;
-
-      // Resolve backend: explicit alias → per-agent config → global default
-      const currentSession = getCurrentSession();
-      const agentId = currentSession?.agentId;
-      const explicitBackend = params.backend
-        ? resolveAlias(aliasMap, params.backend)
-        : undefined;
-      const backend = explicitBackend ?? resolveCodingBackend(codingConfig, agentId);
-      const runner = BACKEND_RUNNERS[backend];
-
-      api.logger.info(`code_run: backend=${backend} agent=${agentId ?? "unknown"}`);
-
-      // Emit prompt summary so Linear users see what's being built
-      const promptSummary = (params.prompt ?? "").slice(0, 200);
-      api.logger.info(`code_run prompt: [${backend}] ${promptSummary}`);
-      if (onUpdate) {
-        try { onUpdate({ status: "running", summary: `[${backend}] ${promptSummary}` }); } catch {}
-      }
+    } as unknown as AnyAgentTool;
 
-      const result = await runner(api, params, pluginConfig);
+    tools.push(tool);
+  }
+
+  const defaultBackend = resolveCodingBackend(codingConfig, ctx.agentId);
+  api.logger.info(`cli tools registered: ${tools.map(t => (t as any).name).join(", ")} (agent default: ${BACKENDS[defaultBackend].toolName})`);
 
-      return jsonResult({
-        success: result.success,
-        backend,
-        output: result.output,
-        ...(result.error ? { error: result.error } : {}),
-      });
-    },
-  } as unknown as AnyAgentTool;
+  return tools;
 }
+
+// Keep backward-compat export for tests that reference the old name
+export const createCodeTool = createCodeTools;

package/src/tools/codex-tool.ts

@@ -1,17 +1,22 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
+import path from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { ActivityContent } from "../api/linear-api.js";
 import {
   buildLinearApi,
   resolveSession,
   extractPrompt,
-  DEFAULT_TIMEOUT_MS,
   DEFAULT_BASE_REPO,
+  formatActivityLogLine,
+  createProgressEmitter,
   type CliToolParams,
   type CliResult,
+  type OnProgressUpdate,
 } from "./cli-shared.js";
 import { InactivityWatchdog, resolveWatchdogConfig } from "../agent/watchdog.js";
+import { isTmuxAvailable, buildSessionName, shellEscape } from "../infra/tmux.js";
+import { runInTmux } from "../infra/tmux-runner.js";
 
 const CODEX_BIN = "codex";
 
@@ -51,7 +56,7 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
     const cleaned = typeof cmd === "string"
       ? cmd.replace(/^\/usr\/bin\/\w+ -lc ['"]?/, "").replace(/['"]?$/, "")
       : JSON.stringify(cmd);
-    const truncated = output.length > 500 ? output.slice(0, 500) + "..." : output;
+    const truncated = output.length > 1000 ? output.slice(0, 1000) + "..." : output;
     return {
       type: "action",
       action: `${cleaned.slice(0, 150)}`,
@@ -63,7 +68,8 @@ function mapCodexEventToActivity(event: any): ActivityContent | null {
   if (eventType === "item.completed" && item?.type === "file_changes") {
     const files = item.files ?? [];
     const fileList = Array.isArray(files) ? files.join(", ") : String(files);
-    return { type: "action", action: "Modified files", parameter: fileList || "unknown files" };
+    const preview = (item.diff ?? item.content ?? "").slice(0, 500) || undefined;
+    return { type: "action", action: "Modified files", parameter: fileList || "unknown files", result: preview };
   }
 
   if (eventType === "turn.completed") {
@@ -87,6 +93,7 @@ export async function runCodex(
   api: OpenClawPluginApi,
   params: CliToolParams,
   pluginConfig?: Record<string, unknown>,
+  onUpdate?: OnProgressUpdate,
 ): Promise<CliResult> {
   api.logger.info(`codex_run params: ${JSON.stringify(params).slice(0, 500)}`);
 
@@ -100,7 +107,7 @@ export async function runCodex(
   }
 
   const { model, timeoutMs } = params;
-  const { agentSessionId, issueIdentifier } = resolveSession(params);
+  const { agentSessionId, issueId, issueIdentifier } = resolveSession(params);
 
   api.logger.info(`codex_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
 
@@ -127,11 +134,50 @@ export async function runCodex(
   args.push("-C", workingDir);
   args.push(prompt);
 
-  api.logger.info(`Codex exec: ${CODEX_BIN} ${args.join(" ").slice(0, 200)}...`);
+  const fullCommand = `${CODEX_BIN} ${args.join(" ")}`;
+  api.logger.info(`Codex exec: ${fullCommand.slice(0, 200)}...`);
+
+  const progressHeader = `[codex] ${workingDir}\n$ ${fullCommand.slice(0, 500)}\n\nPrompt: ${prompt}`;
+
+  // --- tmux path: run inside a tmux session with pipe-pane streaming ---
+  const tmuxEnabled = pluginConfig?.enableTmux !== false;
+  if (tmuxEnabled && isTmuxAvailable()) {
+    const sessionName = buildSessionName(issueIdentifier ?? "unknown", "codex", 0);
+    const tmuxIssueId = issueId ?? sessionName;
+    const modelArgs = (model ?? pluginConfig?.codexModel)
+      ? `--model ${shellEscape((model ?? pluginConfig?.codexModel) as string)}`
+      : "";
+    const cmdStr = [
+      CODEX_BIN, "exec", "--full-auto", "--json", "--ephemeral",
+      modelArgs,
+      "-C", shellEscape(workingDir),
+      shellEscape(prompt),
+    ].filter(Boolean).join(" ");
+
+    return runInTmux({
+      issueId: tmuxIssueId,
+      issueIdentifier: issueIdentifier ?? "unknown",
+      sessionName,
+      command: cmdStr,
+      cwd: workingDir,
+      timeoutMs: timeout,
+      watchdogMs: wdConfig.inactivityMs,
+      logPath: path.join(workingDir, ".claw", `tmux-${sessionName}.jsonl`),
+      mapEvent: mapCodexEventToActivity,
+      linearApi: linearApi ?? undefined,
+      agentSessionId: agentSessionId ?? undefined,
+      steeringMode: "one-shot",
+      logger: api.logger,
+      onUpdate,
+      progressHeader,
+    });
+  }
 
+  // --- fallback: direct spawn ---
   return new Promise<CliResult>((resolve) => {
     const child = spawn(CODEX_BIN, args, {
       stdio: ["ignore", "pipe", "pipe"],
+      cwd: workingDir,
       env: { ...process.env },
       timeout: 0,
     });
@@ -162,6 +208,9 @@ export async function runCodex(
     const collectedCommands: string[] = [];
     let stderrOutput = "";
 
+    const progress = createProgressEmitter({ header: progressHeader, onUpdate });
+    progress.emitHeader();
+
     const rl = createInterface({ input: child.stdout! });
     rl.on("line", (line) => {
       if (!line.trim()) return;
@@ -200,10 +249,13 @@ export async function runCodex(
       }
 
       const activity = mapCodexEventToActivity(event);
-      if (activity && linearApi && agentSessionId) {
-        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
-          api.logger.warn(`Failed to emit Codex activity: ${err}`);
-        });
+      if (activity) {
+        if (linearApi && agentSessionId) {
+          linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+            api.logger.warn(`Failed to emit Codex activity: ${err}`);
+          });
+        }
+        progress.push(formatActivityLogLine(activity));
       }
     });