@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 11
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint
+        run: pnpm lint
+
+      - name: Test with coverage (100% thresholds)
+        run: pnpm test:coverage
+
+      - name: Build
+        run: pnpm build
@@ -1,5 +1,9 @@
 # opencode-mcp
 
+[![CI](https://github.com/alejandro-technology/opencode-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/alejandro-technology/opencode-mcp/actions/workflows/ci.yml)
+[![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/alejandro-technology/opencode-mcp/blob/main/vitest.config.ts)
+[![npm](https://img.shields.io/npm/v/mcp-server-opencode)](https://www.npmjs.com/package/mcp-server-opencode)
+
 An MCP (Model Context Protocol) server that lets any MCP host — Claude Code, Codex CLI, Cursor, etc. — drive an [OpenCode](https://opencode.ai) instance and delegate work to its subagents — so orchestrator models like Opus or Fable can hand off tasks to the other models OpenCode exposes.
 
 ```
@@ -29,9 +33,9 @@ Task delegation is **asynchronous**: starting a task returns immediately with a
 | `opencode_start_task`      | Delegate a task to an agent by starting a new session and prompt (optional `agent` / `model` override)    |
 | `opencode_continue_task`   | Send a follow-up prompt to an existing task's session for iterative back-and-forth with the subagent      |
 | `opencode_cancel_task`     | Abort a running delegated task by cancelling its session                                                  |
-| `opencode_get_task_status` | Poll the status of a delegated task (`pending` / `running` / `completed` / `failed`)                      |
+| `opencode_get_task_status` | Poll the status of a delegated task (`pending` / `running` / `completed` / `failed`); optional `include_progress` adds a partial output snippet and the currently running tool while it's still running |
 | `opencode_get_task_result` | Fetch the final result of a completed task                                                                |
-| `opencode_wait_for_task`   | Long-poll one or more delegated tasks until they finish (`mode: "all"` or `"any"`) or the timeout elapses |
+| `opencode_wait_for_task`   | Long-poll one or more delegated tasks until they finish (`mode: "all"` or `"any"`) or the timeout elapses; optional `include_progress` enriches any still-unfinished tasks in the final result with a partial output snippet and the currently running tool |
 
 
 | Prompt          | Description                                                                                          |
@@ -174,7 +178,7 @@ src/
         └── mcp-result.ts        # jsonResult / jsonError MCP output helpers
 ```
 
-Each module ships with a colocated `*.test.ts` Vitest suite.
+Each module ships with a `*.test.ts` Vitest suite under the parallel `tests/` tree mirroring `src/`.
 
 ## Getting started
 
 
@@ -48,10 +48,58 @@ export async function lastAssistantEntry(
 
 export type TaskStatus = "pending" | "running" | "completed" | "failed";
 
+export interface TaskProgress {
+  /** Last ~500 chars of concatenated TextPart text from the last assistant message. */
+  text_snippet: string;
+  /** Count of ToolPart parts whose state.status is "completed". */
+  tool_calls_completed: number;
+  /** Tool name of the last ToolPart whose state.status is "running" or "pending". */
+  current_tool?: string;
+  /** state.status of that tool part. */
+  current_tool_status?: string;
+}
+
 export interface TaskStatusResult {
   task_id: string;
   status: TaskStatus;
   error?: string;
+  progress?: TaskProgress;
+}
+
+const TEXT_SNIPPET_MAX_LENGTH = 500;
+
+/** Build a TaskProgress summary from a message's parts. */
+export function buildProgress(parts: Part[]): TaskProgress {
+  let text = "";
+  let toolCallsCompleted = 0;
+  let currentTool: string | undefined;
+  let currentToolStatus: string | undefined;
+
+  for (const part of parts) {
+    if (part.type === "text") {
+      text += part.text;
+      continue;
+    }
+    if (part.type === "tool") {
+      if (part.state.status === "completed") {
+        toolCallsCompleted++;
+      } else if (part.state.status === "running" || part.state.status === "pending") {
+        currentTool = part.tool;
+        currentToolStatus = part.state.status;
+      }
+    }
+  }
+
+  return {
+    text_snippet: text.slice(-TEXT_SNIPPET_MAX_LENGTH),
+    tool_calls_completed: toolCallsCompleted,
+    current_tool: currentTool,
+    current_tool_status: currentToolStatus,
+  };
+}
+
+export interface DeriveTaskStatusOptions {
+  includeProgress?: boolean;
 }
 
 /**
@@ -63,11 +111,22 @@ export async function deriveTaskStatus(
   client: OpencodeClient,
   sessionId: string,
   taskId: string,
+  options?: DeriveTaskStatusOptions,
 ): Promise<TaskStatusResult> {
+  const includeProgress = options?.includeProgress ?? false;
+
   // The status map only lists sessions that are actively working.
   const statusRes = await client.session.status();
   const sessionStatus = statusRes.data?.[sessionId];
   if (sessionStatus?.type === "busy" || sessionStatus?.type === "retry") {
+    if (includeProgress) {
+      const entry = await lastAssistantEntry(client, sessionId);
+      return {
+        task_id: taskId,
+        status: "running",
+        progress: entry ? buildProgress(entry.parts) : undefined,
+      };
+    }
     return { task_id: taskId, status: "running" };
   }
 
@@ -82,5 +141,9 @@ export async function deriveTaskStatus(
   if (entry.info.time.completed) {
     return { task_id: taskId, status: "completed" };
   }
-  return { task_id: taskId, status: "running" };
+  return {
+    task_id: taskId,
+    status: "running",
+    progress: includeProgress ? buildProgress(entry.parts) : undefined,
+  };
 }
@@ -10,17 +10,25 @@ export function registerOpencodeGetTaskStatus(server: McpServer) {
       description: "Get the current status of a delegated task",
       inputSchema: {
         task_id: z.string().describe("Id of the task to check"),
+        include_progress: z
+          .boolean()
+          .optional()
+          .describe(
+            "If true, include a partial output snippet and the currently running tool while the task is still running",
+          ),
       },
     },
-    async ({ task_id }) => {
+    async ({ task_id, include_progress }) => {
       const resolved = clientForTask(task_id);
       if (!resolved) {
         return jsonError({ task_id, status: "not_found" });
       }
       const { client, sessionId } = resolved;
 
       try {
-        const result = await deriveTaskStatus(client, sessionId, task_id);
+        const result = await deriveTaskStatus(client, sessionId, task_id, {
+          includeProgress: include_progress,
+        });
         return jsonResult(result);
       } catch (error) {
         return jsonError({
 
@@ -25,12 +25,41 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Re-derive status with progress for every task that is not yet finished.
+ * Only called once, right before returning a final result, never inside the
+ * poll loop. Failures are swallowed per-task so one bad re-derivation doesn't
+ * fail the whole call.
+ */
+async function enrichUnfinishedWithProgress(
+  tasks: WaitTaskResult[],
+  taskData: Array<{ task_id: string; client: NonNullable<ReturnType<typeof clientForTask>> }>,
+): Promise<WaitTaskResult[]> {
+  const clientByTaskId = new Map(taskData.map((entry) => [entry.task_id, entry.client]));
+
+  return Promise.all(
+    tasks.map(async (task) => {
+      if (isFinished(task)) return task;
+      // Every task_id in `tasks` was resolved into taskData before polling started.
+      // biome-ignore lint/style/noNonNullAssertion: guaranteed present, see comment above
+      const client = clientByTaskId.get(task.task_id)!;
+      try {
+        return await deriveTaskStatus(client.client, client.sessionId, task.task_id, {
+          includeProgress: true,
+        });
+      } catch {
+        return task;
+      }
+    }),
+  );
+}
+
 export function registerOpencodeWaitForTask(server: McpServer) {
   server.registerTool(
     "opencode_wait_for_task",
     {
       description:
-        "Long-poll one or more delegated tasks until they finish or the timeout elapses. Use mode 'all' to wait for all tasks, or 'any' to return as soon as one completes.",
+        "Long-poll one or more delegated tasks until they finish or the timeout elapses. Use mode 'all' to wait for all tasks, or 'any' to return as soon as one completes. Set include_progress to enrich still-running tasks in the final result with a partial output snippet and the currently running tool.",
       inputSchema: {
         task_ids: z.string().array().min(1).describe("IDs of tasks to wait for"),
         mode: z
@@ -47,9 +76,15 @@ export function registerOpencodeWaitForTask(server: McpServer) {
           .describe(
             `Time between status checks in milliseconds (default ${DEFAULT_POLL_INTERVAL_MS})`,
           ),
+        include_progress: z
+          .boolean()
+          .optional()
+          .describe(
+            "If true, enrich tasks that are still not finished in the returned result with a partial output snippet and the currently running tool (not used during polling, only on the final result)",
+          ),
       },
     },
-    async ({ task_ids, mode = "all", timeout_ms, poll_interval_ms }) => {
+    async ({ task_ids, mode = "all", timeout_ms, poll_interval_ms, include_progress }) => {
       // Fail-fast: check for unknown task IDs before polling starts
       const unknownIds: string[] = [];
       const taskData: Array<{
@@ -105,11 +140,17 @@ export function registerOpencodeWaitForTask(server: McpServer) {
         }
 
         if (mode === "any" && tasks.some(isFinished)) {
-          return jsonResult({ mode, tasks, timed_out: false });
+          const enriched = include_progress
+            ? await enrichUnfinishedWithProgress(tasks, taskData)
+            : tasks;
+          return jsonResult({ mode, tasks: enriched, timed_out: false });
         }
 
         if (Date.now() >= deadline) {
-          return jsonResult({ mode, tasks, timed_out: true });
+          const enriched = include_progress
+            ? await enrichUnfinishedWithProgress(tasks, taskData)
+            : tasks;
+          return jsonResult({ mode, tasks: enriched, timed_out: true });
         }
 
         await sleep(pollInterval);
 
@@ -7,6 +7,7 @@ vi.mock("@opencode-ai/sdk", () => ({
 }));
 
 import {
+  buildProgress,
   clientForServer,
   clientForTask,
   deriveTaskStatus,
@@ -174,4 +175,121 @@ describe("deriveTaskStatus", () => {
     const result = await deriveTaskStatus(client as never, "s1", "task-1");
     expect(result).toEqual({ task_id: "task-1", status: "running" });
   });
+
+  it("does not call messages when includeProgress is false/absent on the busy path", async () => {
+    const messages = vi.fn();
+    const client = {
+      session: { status: vi.fn().mockResolvedValue({ data: { s1: { type: "busy" } } }), messages },
+    };
+    const result = await deriveTaskStatus(client as never, "s1", "task-1");
+    expect(result).toEqual({ task_id: "task-1", status: "running" });
+    expect(messages).not.toHaveBeenCalled();
+  });
+
+  it("includes progress on the busy path when includeProgress is true", async () => {
+    const client = {
+      session: {
+        status: vi.fn().mockResolvedValue({ data: { s1: { type: "busy" } } }),
+        messages: vi.fn().mockResolvedValue({
+          data: [
+            {
+              info: { role: "assistant" },
+              parts: [{ type: "text", text: "hello" }],
+            },
+          ],
+        }),
+      },
+    };
+    const result = await deriveTaskStatus(client as never, "s1", "task-1", {
+      includeProgress: true,
+    });
+    expect(result).toEqual({
+      task_id: "task-1",
+      status: "running",
+      progress: { text_snippet: "hello", tool_calls_completed: 0 },
+    });
+  });
+
+  it("omits progress on the busy path when there is no assistant entry yet", async () => {
+    const client = {
+      session: {
+        status: vi.fn().mockResolvedValue({ data: { s1: { type: "busy" } } }),
+        messages: vi.fn().mockResolvedValue({ data: [] }),
+      },
+    };
+    const result = await deriveTaskStatus(client as never, "s1", "task-1", {
+      includeProgress: true,
+    });
+    expect(result).toEqual({ task_id: "task-1", status: "running", progress: undefined });
+  });
+
+  it("includes progress on the not-completed fallback path when includeProgress is true", async () => {
+    const client = {
+      session: {
+        status: vi.fn().mockResolvedValue({ data: {} }),
+        messages: vi.fn().mockResolvedValue({
+          data: [
+            {
+              info: { role: "assistant", time: {} },
+              parts: [{ type: "text", text: "still working" }],
+            },
+          ],
+        }),
+      },
+    };
+    const result = await deriveTaskStatus(client as never, "s1", "task-1", {
+      includeProgress: true,
+    });
+    expect(result).toEqual({
+      task_id: "task-1",
+      status: "running",
+      progress: { text_snippet: "still working", tool_calls_completed: 0 },
+    });
+  });
+});
+
+describe("buildProgress", () => {
+  it("concatenates text parts and truncates the snippet to the last ~500 chars", () => {
+    const longText = "a".repeat(300) + "b".repeat(300);
+    const parts = [
+      { type: "text", text: "a".repeat(300) },
+      { type: "text", text: "b".repeat(300) },
+    ];
+    const progress = buildProgress(parts as never);
+    expect(progress.text_snippet).toBe(longText.slice(-500));
+    expect(progress.text_snippet.length).toBe(500);
+    expect(progress.tool_calls_completed).toBe(0);
+  });
+
+  it("counts completed tool parts and tracks the last running/pending tool", () => {
+    const parts = [
+      { type: "tool", tool: "read", state: { status: "completed" } },
+      { type: "tool", tool: "grep", state: { status: "completed" } },
+      { type: "tool", tool: "edit", state: { status: "pending" } },
+      { type: "tool", tool: "write", state: { status: "running" } },
+    ];
+    const progress = buildProgress(parts as never);
+    expect(progress.tool_calls_completed).toBe(2);
+    expect(progress.current_tool).toBe("write");
+    expect(progress.current_tool_status).toBe("running");
+  });
+
+  it("ignores error tool parts and leaves current_tool undefined when nothing is running/pending", () => {
+    const parts = [{ type: "tool", tool: "bash", state: { status: "error" } }];
+    const progress = buildProgress(parts as never);
+    expect(progress.tool_calls_completed).toBe(0);
+    expect(progress.current_tool).toBeUndefined();
+    expect(progress.current_tool_status).toBeUndefined();
+  });
+
+  it("ignores part types that are neither text nor tool", () => {
+    const parts = [{ type: "step-start" }];
+    const progress = buildProgress(parts as never);
+    expect(progress).toEqual({ text_snippet: "", tool_calls_completed: 0 });
+  });
+
+  it("returns an empty snippet when there are no parts", () => {
+    const progress = buildProgress([]);
+    expect(progress).toEqual({ text_snippet: "", tool_calls_completed: 0 });
+  });
 });