tower-studio 0.1.2 → 0.1.5

package/.next/standalone/tower/src/mcp/tools/report-tools.ts

@@ -1,214 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-const PRIORITY_ORDER: Record<string, number> = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
-
-export const reportTools = {
-  daily_summary: {
-    description:
-      "Get a summary of today's work across all workspaces. Shows completed tasks, in-progress tasks with their last chat summary, grouped by workspace → project. Also includes session-insight notes created that day in an `insights` array. Optionally pass a date (YYYY-MM-DD) to query a specific day. Date boundary is server-local time.",
-    schema: z.object({
-      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
-        .describe("Date in YYYY-MM-DD format. Defaults to today."),
-    }),
-    handler: async (args: { date?: string }) => {
-      const date = args.date ? new Date(args.date + "T00:00:00") : new Date();
-      date.setHours(0, 0, 0, 0);
-      const nextDay = new Date(date);
-      nextDay.setDate(nextDay.getDate() + 1);
-
-      const tasks = await db.task.findMany({
-        where: {
-          OR: [
-            { updatedAt: { gte: date, lt: nextDay } },
-            { executions: { some: { startedAt: { gte: date, lt: nextDay } } } },
-            { messages: { some: { createdAt: { gte: date, lt: nextDay } } } },
-          ],
-        },
-        include: {
-          project: { include: { workspace: true } },
-          messages: {
-            where: { role: "ASSISTANT", createdAt: { gte: date, lt: nextDay } },
-            orderBy: { createdAt: "desc" },
-            take: 1,
-            select: { content: true, createdAt: true },
-          },
-          executions: {
-            where: { startedAt: { gte: date, lt: nextDay } },
-            orderBy: { startedAt: "desc" },
-            take: 1,
-            select: { startedAt: true, status: true, summary: true },
-          },
-        },
-        orderBy: { updatedAt: "desc" },
-      });
-
-      // Group by workspace → project
-      type CompletedTask = { id: string; title: string; priority: string; completedAt: string };
-      type InProgressTask = { id: string; title: string; status: string; priority: string; lastActivity: string; progressSummary: string | null };
-      type ProjectEntry = { id: string; name: string; alias: string | null; completed: CompletedTask[]; inProgress: InProgressTask[] };
-      type WsEntry = { id: string; name: string; projects: Map<string, ProjectEntry> };
-
-      const wsMap = new Map<string, WsEntry>();
-
-      for (const task of tasks) {
-        const ws = task.project.workspace;
-        if (!wsMap.has(ws.id)) {
-          wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
-        }
-        const projMap = wsMap.get(ws.id)!.projects;
-        const proj = task.project;
-        if (!projMap.has(proj.id)) {
-          projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, completed: [], inProgress: [] });
-        }
-        const projEntry = projMap.get(proj.id)!;
-
-        if (task.status === "DONE") {
-          projEntry.completed.push({
-            id: task.id, title: task.title, priority: task.priority,
-            completedAt: task.updatedAt.toISOString(),
-          });
-        } else if (task.status !== "CANCELLED") {
-          projEntry.inProgress.push({
-            id: task.id, title: task.title, status: task.status, priority: task.priority,
-            lastActivity: (task.messages[0]?.createdAt ?? task.updatedAt).toISOString(),
-            progressSummary: task.executions[0]?.summary
-              ?? (task.messages[0]?.content
-                ? task.messages[0].content.slice(0, 200) + (task.messages[0].content.length > 200 ? "..." : "")
-                : null),
-          });
-        }
-      }
-
-      // Query session-insight notes created that day
-      const insightNotes = await db.projectNote.findMany({
-        where: {
-          category: "session-insight",
-          createdAt: { gte: date, lt: nextDay },
-        },
-        include: {
-          project: {
-            include: { workspace: true },
-          },
-          task: { select: { id: true, title: true } },
-        },
-        orderBy: { createdAt: "desc" },
-      });
-
-      const insights = insightNotes.map((note) => ({
-        id: note.id,
-        title: note.title,
-        content: note.content.slice(0, 500),
-        createdAt: note.createdAt.toISOString(),
-        workspace: { id: note.project.workspace.id, name: note.project.workspace.name },
-        project: { id: note.project.id, name: note.project.name, alias: note.project.alias },
-        task: note.task ? { id: note.task.id, title: note.task.title } : null,
-      }));
-
-      let totalCompleted = 0;
-      let totalInProgress = 0;
-      const workspaces = Array.from(wsMap.values()).map((ws) => ({
-        id: ws.id, name: ws.name,
-        projects: Array.from(ws.projects.values()).map((p) => {
-          totalCompleted += p.completed.length;
-          totalInProgress += p.inProgress.length;
-          return { id: p.id, name: p.name, alias: p.alias, completed: p.completed, inProgress: p.inProgress };
-        }),
-      }));
-
-      return {
-        date: date.toISOString().slice(0, 10),
-        workspaces,
-        stats: { totalCompleted, totalInProgress, totalActive: totalCompleted + totalInProgress },
-        insights,
-        insightCount: insights.length,
-      };
-    },
-  },
-
-  daily_todo: {
-    description:
-      "Get all pending tasks (TODO, IN_PROGRESS, IN_REVIEW) across all workspaces, grouped by workspace → project. Supports filtering by workspace, project, status, and priority. Sorted by priority severity (CRITICAL first). Returns lastSessionId for resuming tasks.",
-    schema: z.object({
-      workspaceId: z.string().optional().describe("Filter by workspace ID"),
-      projectId: z.string().optional().describe("Filter by project ID"),
-      status: z.array(z.enum(["TODO", "IN_PROGRESS", "IN_REVIEW"])).optional()
-        .describe("Filter by status. Defaults to all three."),
-      priority: z.array(z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"])).optional()
-        .describe("Filter by priority levels"),
-    }),
-    handler: async (args: {
-      workspaceId?: string;
-      projectId?: string;
-      status?: ("TODO" | "IN_PROGRESS" | "IN_REVIEW")[];
-      priority?: ("LOW" | "MEDIUM" | "HIGH" | "CRITICAL")[];
-    }) => {
-      const statusFilter = args.status ?? ["TODO", "IN_PROGRESS", "IN_REVIEW"];
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const where: any = { status: { in: statusFilter } };
-      if (args.priority) where.priority = { in: args.priority };
-      if (args.projectId) where.projectId = args.projectId;
-      if (args.workspaceId) where.project = { workspaceId: args.workspaceId };
-
-      const tasks = await db.task.findMany({
-        where,
-        include: {
-          project: { include: { workspace: true } },
-          labels: { include: { label: true } },
-          executions: {
-            where: { sessionId: { not: null } },
-            orderBy: { createdAt: "desc" },
-            take: 1,
-            select: { sessionId: true },
-          },
-        },
-      });
-
-      // Sort by priority severity (CRITICAL first), then by updatedAt desc
-      tasks.sort((a, b) =>
-        (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99)
-        || b.updatedAt.getTime() - a.updatedAt.getTime()
-      );
-
-      // Group by workspace → project
-      type FormattedTask = { id: string; title: string; status: string; priority: string; labels: string[]; createdAt: string; lastSessionId: string | null };
-      type ProjEntry = { id: string; name: string; alias: string | null; tasks: FormattedTask[] };
-      type WsEntry = { id: string; name: string; projects: Map<string, ProjEntry> };
-
-      const wsMap = new Map<string, WsEntry>();
-
-      for (const task of tasks) {
-        const ws = task.project.workspace;
-        if (!wsMap.has(ws.id)) wsMap.set(ws.id, { id: ws.id, name: ws.name, projects: new Map() });
-        const projMap = wsMap.get(ws.id)!.projects;
-        const proj = task.project;
-        if (!projMap.has(proj.id)) projMap.set(proj.id, { id: proj.id, name: proj.name, alias: proj.alias, tasks: [] });
-        projMap.get(proj.id)!.tasks.push({
-          id: task.id, title: task.title, status: task.status, priority: task.priority,
-          labels: task.labels.map((tl) => tl.label.name),
-          createdAt: task.createdAt.toISOString(),
-          lastSessionId: task.executions[0]?.sessionId ?? null,
-        });
-      }
-
-      const byStatus = { TODO: 0, IN_PROGRESS: 0, IN_REVIEW: 0 };
-      const byPriority = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
-      for (const t of tasks) {
-        if (t.status in byStatus) byStatus[t.status as keyof typeof byStatus]++;
-        if (t.priority in byPriority) byPriority[t.priority as keyof typeof byPriority]++;
-      }
-
-      return {
-        date: new Date().toISOString().slice(0, 10),
-        workspaces: Array.from(wsMap.values()).map((ws) => ({
-          id: ws.id, name: ws.name,
-          projects: Array.from(ws.projects.values()).map((p) => ({
-            id: p.id, name: p.name, alias: p.alias, tasks: p.tasks,
-          })),
-        })),
-        stats: { total: tasks.length, byStatus, byPriority },
-      };
-    },
-  },
-};

package/.next/standalone/tower/src/mcp/tools/search-tools.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-import { search, type SearchCategory } from "@/lib/search";
-import { readConfigValue } from "@/lib/config-reader";
-
-export const searchTools = {
-  search: {
-    description:
-      "Search for tasks, projects, repositories, notes, or assets by a query string. Use category 'all' to search across all types.",
-    schema: z.object({
-      query: z.string(),
-      category: z
-        .enum(["task", "project", "repository", "note", "asset", "all"])
-        .default("task")
-        .optional(),
-    }),
-    handler: async (args: {
-      query: string;
-      category?: SearchCategory;
-    }) => {
-      const [resultLimit, allModeCap, snippetLength] = await Promise.all([
-        readConfigValue<number>("search.resultLimit", 20),
-        readConfigValue<number>("search.allModeCap", 5),
-        readConfigValue<number>("search.snippetLength", 80),
-      ]);
-      return search(args.query, args.category ?? "task", {
-        resultLimit,
-        allModeCap,
-        snippetLength,
-      });
-    },
-  },
-};

package/.next/standalone/tower/src/mcp/tools/task-tools.ts

@@ -1,250 +0,0 @@
-import { z } from "zod";
-import { execFileSync } from "child_process";
-import { copyFileSync, existsSync, statSync, mkdirSync } from "fs";
-import { basename, extname, join, resolve } from "path";
-import { db } from "../db";
-import { stripCacheUuidSuffix, isAssistantCachePath } from "@/lib/file-utils";
-
-// Derive project root from this file's location (src/mcp/tools/ → ../../..)
-// This avoids depending on process.cwd() which varies when MCP is spawned from .tower/
-const MCP_PROJECT_ROOT = resolve(__dirname, "../../..");
-
-const TaskStatus = z.enum(["TODO", "IN_PROGRESS", "IN_REVIEW", "DONE", "CANCELLED"]);
-const Priority = z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]);
-
-export const taskTools = {
-  list_tasks: {
-    description: "List all tasks in a project, optionally filtered by status. Includes labels and is ordered by position then creation date.",
-    schema: z.object({
-      projectId: z.string(),
-      status: TaskStatus.optional(),
-    }),
-    handler: async (args: { projectId: string; status?: string }) => {
-      const tasks = await db.task.findMany({
-        where: {
-          projectId: args.projectId,
-          ...(args.status ? { status: args.status as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED" } : {}),
-        },
-        include: {
-          labels: { include: { label: true } },
-        },
-        orderBy: [{ order: "asc" }, { createdAt: "desc" }],
-      });
-
-      return tasks.map((task) => ({
-        ...task,
-        labels: task.labels.map((tl) => tl.label),
-      }));
-    },
-  },
-
-  create_task: {
-    description: "Create a new task in a project. Priority defaults to MEDIUM, status defaults to TODO. Set useWorktree=true for branch isolation. Set autoStart=true (default) to immediately start execution. Pass references as file paths to attach as project assets.",
-    schema: z.object({
-      projectId: z.string(),
-      title: z.string(),
-      description: z.string().optional(),
-      priority: Priority.optional().default("MEDIUM"),
-      status: TaskStatus.optional().default("TODO"),
-      labelIds: z.array(z.string()).optional(),
-      subPath: z.string().optional(),
-      useWorktree: z.boolean().optional().default(false),
-      baseBranch: z.string().optional().describe("Base branch for worktree checkout. Only used when useWorktree=true. If omitted, auto-detects the project's current branch."),
-      autoStart: z.boolean().optional().default(true),
-      references: z.array(z.string()).max(20).optional(),
-    }),
-    handler: async (args: {
-      projectId: string;
-      title: string;
-      description?: string;
-      priority?: string;
-      status?: string;
-      labelIds?: string[];
-      subPath?: string;
-      useWorktree?: boolean;
-      baseBranch?: string;
-      autoStart?: boolean;
-      references?: string[];
-    }) => {
-      // Determine baseBranch: explicit param > auto-detect from project's current git branch
-      let baseBranch: string | null = null;
-      if (args.useWorktree) {
-        if (args.baseBranch) {
-          baseBranch = args.baseBranch;
-        } else {
-          const project = await db.project.findUnique({ where: { id: args.projectId }, select: { localPath: true } });
-          if (project?.localPath) {
-            try {
-              baseBranch = execFileSync("git", ["branch", "--show-current"], {
-                cwd: project.localPath, encoding: "utf-8", timeout: 5000,
-              }).trim() || null;
-            } catch {
-              // fallback: no baseBranch, task runs in direct mode
-            }
-          }
-        }
-      }
-
-      const task = await db.task.create({
-        data: {
-          title: args.title,
-          description: args.description,
-          projectId: args.projectId,
-          priority: (args.priority ?? "MEDIUM") as "LOW" | "MEDIUM" | "HIGH" | "CRITICAL",
-          status: (args.status ?? "TODO") as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED",
-          baseBranch,
-        },
-      });
-
-      if (args.labelIds && args.labelIds.length > 0) {
-        await db.taskLabel.createMany({
-          data: args.labelIds.map((labelId) => ({ taskId: task.id, labelId })),
-        });
-      }
-
-      // Copy reference files to assets and create ProjectAsset records
-      const attachedFiles: string[] = [];
-      let updatedDesc: string | null = null;
-      if (args.references && args.references.length > 0) {
-        const assetsDir = join(MCP_PROJECT_ROOT, "data", "assets", args.projectId);
-        mkdirSync(assetsDir, { recursive: true });
-
-        for (const filePath of args.references) {
-          try {
-            if (!existsSync(filePath)) continue;
-            const stat = statSync(filePath);
-            if (!stat.isFile()) continue;
-
-            const isCache = isAssistantCachePath(filePath);
-            let filename = isCache
-              ? stripCacheUuidSuffix(basename(filePath))
-              : basename(filePath);
-            // Avoid overwriting existing assets
-            if (existsSync(join(assetsDir, filename))) {
-              const ext = extname(filename);
-              const base = basename(filename, ext);
-              if (isCache) {
-                // Use counter suffix for readable cache asset names: "设计稿 (1).png"
-                let counter = 1;
-                while (existsSync(join(assetsDir, `${base} (${counter})${ext}`))) {
-                  counter++;
-                }
-                filename = `${base} (${counter})${ext}`;
-              } else {
-                filename = `${base}-${Date.now()}${ext}`;
-              }
-            }
-            const dest = join(assetsDir, filename);
-            copyFileSync(filePath, dest);
-
-            await db.projectAsset.create({
-              data: {
-                filename,
-                path: dest,
-                size: stat.size,
-                projectId: args.projectId,
-                taskId: task.id,
-                description: `Reference: ${basename(filePath)}`,
-              },
-            });
-            attachedFiles.push(filename);
-          } catch {
-            // Skip files that can't be copied
-          }
-        }
-
-        // Append reference info to task description with full absolute paths
-        if (attachedFiles.length > 0) {
-          const refText = attachedFiles.map((f) => `- ${join(assetsDir, f)}`).join("\n");
-          updatedDesc = (task.description ?? "") + `\n\nAttached references:\n${refText}`;
-          await db.task.update({ where: { id: task.id }, data: { description: updatedDesc } });
-        }
-      }
-
-      // Auto-start execution if requested — use locally-built description (no extra DB query)
-      if (args.autoStart) {
-        const PORT = process.env.PORT ?? "3000";
-        const prompt = updatedDesc || args.description || args.title;
-        try {
-          const res = await fetch(`http://localhost:${PORT}/api/internal/terminal/${task.id}/start`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ prompt }),
-          });
-          if (res.ok) {
-            const execData = await res.json();
-            return { ...task, execution: execData };
-          }
-        } catch {
-          // Task created but auto-start failed — return task anyway
-        }
-      }
-
-      return task;
-    },
-  },
-
-  update_task: {
-    description: "Update a task's title, description, priority, labels, and/or subPath. If labelIds is provided, replaces all existing labels.",
-    schema: z.object({
-      taskId: z.string(),
-      title: z.string().optional(),
-      description: z.string().optional(),
-      priority: Priority.optional(),
-      labelIds: z.array(z.string()).optional(),
-      subPath: z.string().optional(),
-    }),
-    handler: async (args: {
-      taskId: string;
-      title?: string;
-      description?: string;
-      priority?: string;
-      labelIds?: string[];
-      subPath?: string;
-    }) => {
-      const { labelIds, taskId, ...updateData } = args;
-
-      return db.$transaction(async (tx) => {
-        const task = await tx.task.update({
-          where: { id: taskId },
-          data: updateData as { title?: string; description?: string; priority?: "LOW" | "MEDIUM" | "HIGH" | "CRITICAL"; subPath?: string },
-        });
-
-        if (labelIds !== undefined) {
-          await tx.taskLabel.deleteMany({ where: { taskId } });
-          if (labelIds.length > 0) {
-            await tx.taskLabel.createMany({
-              data: labelIds.map((labelId) => ({ taskId, labelId })),
-            });
-          }
-        }
-
-        return task;
-      });
-    },
-  },
-
-  move_task: {
-    description: "Move a task to a different status column (e.g. TODO, IN_PROGRESS, IN_REVIEW, DONE, CANCELLED).",
-    schema: z.object({
-      taskId: z.string(),
-      status: TaskStatus,
-    }),
-    handler: async (args: { taskId: string; status: string }) => {
-      // Delegate to updateTaskStatus to trigger side effects (dreaming on DONE, worktree cleanup on CANCELLED, etc.)
-      const { updateTaskStatus } = await import("@/actions/task-actions");
-      return updateTaskStatus(args.taskId, args.status as "TODO" | "IN_PROGRESS" | "IN_REVIEW" | "DONE" | "CANCELLED");
-    },
-  },
-
-  delete_task: {
-    description: "Delete a task by ID.",
-    schema: z.object({
-      taskId: z.string(),
-    }),
-    handler: async (args: { taskId: string }) => {
-      await db.task.delete({ where: { id: args.taskId } });
-      return { deleted: true, taskId: args.taskId };
-    },
-  },
-};

package/.next/standalone/tower/src/mcp/tools/terminal-tools.ts

@@ -1,154 +0,0 @@
-import { z } from "zod";
-import { db } from "../db";
-
-const PORT = process.env.PORT ?? "3000";
-const BRIDGE_BASE = `http://localhost:${PORT}/api/internal/terminal`;
-const CUID_RE = /^c[a-z0-9]{20,30}$/;
-
-async function bridgeFetch(path: string, init?: RequestInit): Promise<Response> {
-  return fetch(`${BRIDGE_BASE}${path}`, init);
-}
-
-function validateMcpTaskId(taskId: string): string | null {
-  if (!CUID_RE.test(taskId)) return "Invalid taskId format — expected CUID";
-  return null;
-}
-
-export const terminalTools = {
-  start_task_execution: {
-    description:
-      "Start a Claude CLI terminal session for a task. The prompt is sent as the initial instruction. The task status will change to IN_PROGRESS. Returns executionId and worktreePath (if worktree mode).",
-    schema: z.object({
-      taskId: z.string(),
-      prompt: z.string().optional(),
-    }),
-    handler: async (args: { taskId: string; prompt?: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/start`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ prompt: args.prompt ?? "" }),
-      });
-
-      if (response.ok) {
-        const data = await response.json();
-        return { ok: true, ...data };
-      }
-
-      const errData = await response.json().catch(() => ({}));
-      return { error: (errData as Record<string, unknown>).error ?? "Failed to start execution", status: response.status };
-    },
-  },
-
-  get_task_terminal_output: {
-    description:
-      "Get recent terminal output lines from a running task's PTY session. Returns the last N lines (default 50, max 500).",
-    schema: z.object({
-      taskId: z.string(),
-      lines: z.number().int().min(1).max(500).optional(),
-    }),
-    handler: async (args: { taskId: string; lines?: number }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/buffer?lines=${args.lines ?? 50}`);
-
-      if (response.status === 404) {
-        return { error: "No active terminal session for this task", taskId: args.taskId };
-      }
-
-      if (response.ok) {
-        const data = await response.json() as { taskId: string; lines: string[]; total: number; killed: boolean };
-        return { taskId: data.taskId, lines: data.lines, total: data.total, killed: data.killed };
-      }
-
-      return { error: "Bridge request failed", status: response.status };
-    },
-  },
-
-  send_task_terminal_input: {
-    description:
-      "Send text input to a running task's PTY terminal. The text is forwarded directly to the Claude CLI process. Include \\n for Enter key.",
-    schema: z.object({
-      taskId: z.string(),
-      text: z.string().min(1).max(10000),
-    }),
-    handler: async (args: { taskId: string; text: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-      const tid = encodeURIComponent(args.taskId);
-      const response = await bridgeFetch(`/${tid}/input`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ text: args.text }),
-      });
-
-      if (response.status === 404) {
-        return { error: "No active terminal session for this task", taskId: args.taskId };
-      }
-
-      if (response.status === 410) {
-        return { error: "Terminal session has exited", taskId: args.taskId };
-      }
-
-      if (response.ok) {
-        return { ok: true, taskId: args.taskId };
-      }
-
-      return { error: "Bridge request failed", status: response.status };
-    },
-  },
-
-  get_task_execution_status: {
-    description:
-      "Get the execution status of a task including whether its terminal is running, idle, or exited. Also returns a snippet of recent output.",
-    schema: z.object({
-      taskId: z.string(),
-    }),
-    handler: async (args: { taskId: string }) => {
-      const err = validateMcpTaskId(args.taskId);
-      if (err) return { error: err, taskId: args.taskId };
-
-      const execution = await db.taskExecution.findFirst({
-        where: { taskId: args.taskId },
-        orderBy: { createdAt: "desc" },
-      });
-
-      if (!execution) {
-        return { error: "No execution found for this task", taskId: args.taskId };
-      }
-
-      const tid = encodeURIComponent(args.taskId);
-      const bufferResponse = await bridgeFetch(`/${tid}/buffer?lines=10`);
-
-      let terminalStatus: "running" | "exited" | "not_running";
-      let outputSnippet: string | null = null;
-
-      if (bufferResponse.status === 404) {
-        // No active session — check DB status
-        const doneStatuses = ["COMPLETED", "FAILED"];
-        terminalStatus = doneStatuses.includes(execution.status) ? "exited" : "not_running";
-      } else if (bufferResponse.ok) {
-        const bufferData = await bufferResponse.json() as { lines: string[]; killed: boolean };
-        terminalStatus = bufferData.killed ? "exited" : "running";
-        if (bufferData.lines && bufferData.lines.length > 0) {
-          outputSnippet = bufferData.lines.slice(-5).join("\n");
-        }
-      } else {
-        terminalStatus = "not_running";
-      }
-
-      return {
-        taskId: args.taskId,
-        executionId: execution.id,
-        executionStatus: execution.status,
-        terminalStatus,
-        startedAt: execution.startedAt,
-        endedAt: execution.endedAt,
-        outputSnippet,
-      };
-    },
-  },
-};