@mndrk/agx 2.3.3 → 2.4.1

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/items/[id]/recap/route.ts

@@ -0,0 +1,125 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker";
+import { getTrackerRun, listTrackerRuns } from "@/lib/tracker/tracker-run-store";
+import {
+  readLatestRecap,
+  getRecapJob,
+  enqueueRecap,
+} from "@/lib/tracker/recap";
+import { getAdapter } from "@/lib/tracker/registry";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type Ctx = { params: Promise<{ tracker: string; id: string }> };
+
+export async function GET(req: NextRequest, { params }: Ctx) {
+  const { tracker, id } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  const runId = req.nextUrl.searchParams.get("runId")?.trim();
+
+  try {
+    if (runId) {
+      const run = await getTrackerRun(runId);
+      if (run?.recapFilePath) {
+        const { readFile } = await import("fs/promises");
+        const content = await readFile(run.recapFilePath, "utf-8");
+        return NextResponse.json({
+          content,
+          generatedAt: run.updatedAt,
+          filePath: run.recapFilePath,
+          status: "idle",
+          error: null,
+        });
+      }
+    }
+
+    const latest = await readLatestRecap(tracker, id);
+    const job = getRecapJob(tracker, id);
+
+    if (!latest) {
+      const runs = await listTrackerRuns({
+        issueId: id,
+        projectId: projectId ?? null,
+        trackerType: tracker,
+        limit: 1,
+      });
+      const run = runs[0];
+      if (run?.recapFilePath) {
+        const { readFile } = await import("fs/promises");
+        try {
+          const content = await readFile(run.recapFilePath, "utf-8");
+          return NextResponse.json({
+            content,
+            generatedAt: run.updatedAt,
+            filePath: run.recapFilePath,
+            status: job?.status ?? "idle",
+            error: job?.error ?? null,
+          });
+        } catch {
+          /* file missing */
+        }
+      }
+    }
+
+    return NextResponse.json({
+      content: latest?.content ?? null,
+      generatedAt: latest?.generatedAt.toISOString() ?? null,
+      filePath: latest?.filePath ?? null,
+      status: job?.status ?? "idle",
+      error: job?.error ?? null,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to fetch recap";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function POST(req: NextRequest, { params }: Ctx) {
+  const { tracker, id } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+
+  try {
+    const adapter = getAdapter(tracker);
+
+    let itemCtx: Parameters<typeof enqueueRecap>[2];
+    try {
+      const item = await adapter.getItem(projectId ?? "", id);
+      itemCtx = {
+        identifier: item.identifier,
+        title: item.title,
+        status: item.status,
+        assignee: item.assignee?.name,
+        description: item.description,
+      };
+    } catch {
+      // Not an item — likely a group (cycle/sprint). Fetch its tickets.
+      const { items } = await adapter.listItems(projectId ?? "", {
+        groupIds: [id],
+        limit: 50,
+      });
+      const runs = await listTrackerRuns({
+        issueId: id,
+        trackerType: tracker,
+        projectId: projectId ?? null,
+        limit: 1,
+      });
+      const run = runs[0];
+      itemCtx = {
+        identifier: run?.issueIdentifier ?? id,
+        title: run?.issueTitle ?? "Group",
+        status: run?.issueStatus ?? "unknown",
+        tickets: items,
+      };
+    }
+
+    const jobState = enqueueRecap(tracker, id, itemCtx);
+    return NextResponse.json({
+      status: jobState.status,
+      startedAt: new Date(jobState.startedAt).toISOString(),
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to enqueue recap";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/items/[id]/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
+import { updateCachedTrackerItemStatus } from "@/lib/tracker/tracker-item-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string; id: string }> }
+) {
+  const { tracker, id } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const adapter = resolveAdapter(tracker);
+  try {
+    const item = await adapter.getItem(projectId, id);
+    return NextResponse.json({ item });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to fetch item";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string; id: string }> }
+) {
+  const { tracker, id } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const body = (await req.json().catch(() => ({}))) as {
+    status?: string;
+    assigneeId?: string;
+    priority?: string;
+    labels?: string[];
+  };
+
+  const adapter = resolveAdapter(tracker);
+  try {
+    const updated = await adapter.updateItem(projectId, id, body);
+
+    // Keep the cache in sync so the board list reflects the new state immediately
+    if (body.status && updated.status && updated.updatedAt) {
+      await updateCachedTrackerItemStatus({
+        issueId: updated.id,
+        status: updated.status,
+        updatedAt: updated.updatedAt,
+      });
+    }
+
+    return NextResponse.json({ item: updated });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to update item";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/items/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
+import type { TrackerStatusCategory, TrackerFilters } from "@/lib/tracker/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const adapter = resolveAdapter(tracker);
+
+  const sortByRaw = req.nextUrl.searchParams.get("sortBy");
+  const sortDirRaw = req.nextUrl.searchParams.get("sortDir");
+
+  const filters: TrackerFilters = {
+    statuses: req.nextUrl.searchParams.getAll("status"),
+    statusCategories: req.nextUrl.searchParams.getAll("statusCategory") as TrackerStatusCategory[],
+    assigneeIds: req.nextUrl.searchParams.getAll("assigneeId"),
+    groupIds: req.nextUrl.searchParams.getAll("groupId"),
+    search: req.nextUrl.searchParams.get("search") ?? undefined,
+    cursor: req.nextUrl.searchParams.get("cursor") ?? undefined,
+    limit: req.nextUrl.searchParams.get("limit")
+      ? Number(req.nextUrl.searchParams.get("limit"))
+      : undefined,
+    sortBy: sortByRaw as TrackerFilters["sortBy"] ?? undefined,
+    sortDir: sortDirRaw === "asc" || sortDirRaw === "desc" ? sortDirRaw : undefined,
+    hasActivity: req.nextUrl.searchParams.get("hasActivity") === "true" || undefined,
+  };
+
+  try {
+    const result = await adapter.listItems(projectId, filters);
+    return NextResponse.json(result);
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to fetch items";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/{linear → trackers/[tracker]}/mcp-setup/route.ts

@@ -1,4 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
@@ -11,9 +13,9 @@ interface CliConfigInfo {
   path: string;
   read: () => Record<string, unknown>;
   write: (config: Record<string, unknown>) => void;
-  hasLinearMcp: (config: Record<string, unknown>) => boolean;
-  addLinearMcp: (config: Record<string, unknown>) => Record<string, unknown>;
-  removeLinearMcp: (config: Record<string, unknown>) => Record<string, unknown>;
+  hasMcpServer: (config: Record<string, unknown>, serverKey: string) => boolean;
+  addMcpServer: (config: Record<string, unknown>, serverKey: string, serverValue: unknown) => Record<string, unknown>;
+  removeMcpServer: (config: Record<string, unknown>, serverKey: string) => Record<string, unknown>;
 }
 
 function getCliConfigInfo(cli: string): CliConfigInfo | null {
@@ -31,18 +33,18 @@ function getCliConfigInfo(cli: string): CliConfigInfo | null {
         write: (config) => {
           writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
         },
-        hasLinearMcp: (config) => {
+        hasMcpServer: (config, serverKey) => {
           const servers = config.mcpServers as Record<string, unknown> | undefined;
-          return !!servers?.linear;
+          return !!servers?.[serverKey];
         },
-        addLinearMcp: (config) => {
+        addMcpServer: (config, serverKey, serverValue) => {
           const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
-          servers.linear = { type: "url", url: "https://mcp.linear.app/sse" };
+          servers[serverKey] = serverValue;
           return { ...config, mcpServers: servers };
         },
-        removeLinearMcp: (config) => {
+        removeMcpServer: (config, serverKey) => {
           const servers = config.mcpServers as Record<string, unknown> | undefined;
-          if (servers?.linear) delete servers.linear;
+          if (servers?.[serverKey]) delete servers[serverKey];
           return config;
         },
       };
@@ -59,18 +61,18 @@ function getCliConfigInfo(cli: string): CliConfigInfo | null {
         write: (config) => {
           writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
         },
-        hasLinearMcp: (config) => {
+        hasMcpServer: (config, serverKey) => {
           const servers = config.mcpServers as Record<string, unknown> | undefined;
-          return !!servers?.linear;
+          return !!servers?.[serverKey];
         },
-        addLinearMcp: (config) => {
+        addMcpServer: (config, serverKey, serverValue) => {
           const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
-          servers.linear = { type: "url", url: "https://mcp.linear.app/sse" };
+          servers[serverKey] = serverValue;
           return { ...config, mcpServers: servers };
         },
-        removeLinearMcp: (config) => {
+        removeMcpServer: (config, serverKey) => {
           const servers = config.mcpServers as Record<string, unknown> | undefined;
-          if (servers?.linear) delete servers.linear;
+          if (servers?.[serverKey]) delete servers[serverKey];
           return config;
         },
       };
@@ -87,18 +89,18 @@ function getCliConfigInfo(cli: string): CliConfigInfo | null {
         write: (config) => {
           writeFileSync(configPath, stringifyToml(config as Parameters<typeof stringifyToml>[0]) + "\n");
         },
-        hasLinearMcp: (config) => {
+        hasMcpServer: (config, serverKey) => {
           const servers = config.mcp_servers as Record<string, unknown> | undefined;
-          return !!servers?.linear;
+          return !!servers?.[serverKey];
         },
-        addLinearMcp: (config) => {
+        addMcpServer: (config, serverKey, serverValue) => {
           const servers = (config.mcp_servers ?? {}) as Record<string, unknown>;
-          servers.linear = { url: "https://mcp.linear.app/mcp" };
+          servers[serverKey] = serverValue;
           return { ...config, mcp_servers: servers };
         },
-        removeLinearMcp: (config) => {
+        removeMcpServer: (config, serverKey) => {
           const servers = config.mcp_servers as Record<string, unknown> | undefined;
-          if (servers?.linear) delete servers.linear;
+          if (servers?.[serverKey]) delete servers[serverKey];
           return config;
         },
       };
@@ -109,8 +111,19 @@ function getCliConfigInfo(cli: string): CliConfigInfo | null {
   }
 }
 
-// GET: Check MCP config status for each CLI
-export async function GET() {
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const adapter = resolveAdapter(tracker);
+  const mcpConfig = adapter.getMcpConfig?.(req.nextUrl.searchParams.get("projectId") ?? "");
+
+  if (!mcpConfig) {
+    return NextResponse.json({ configured: {} });
+  }
+
+  const serverKey = mcpConfig.name;
   const results: Record<string, boolean> = {};
 
   for (const cli of ["claude", "codex", "gemini"]) {
@@ -121,7 +134,7 @@ export async function GET() {
     }
     try {
       const config = info.read();
-      results[cli] = info.hasLinearMcp(config);
+      results[cli] = info.hasMcpServer(config, serverKey);
     } catch {
       results[cli] = false;
     }
@@ -130,15 +143,25 @@ export async function GET() {
   return NextResponse.json({ configured: results });
 }
 
-// POST: Configure MCP for a specific CLI
-export async function POST(request: NextRequest) {
-  const body = (await request.json()) as { cli: string };
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const body = (await req.json()) as { cli: string };
   const { cli } = body;
 
   if (!cli) {
     return NextResponse.json({ error: "Missing cli parameter" }, { status: 400 });
   }
 
+  const adapter = resolveAdapter(tracker);
+  const mcpConfig = adapter.getMcpConfig?.(req.nextUrl.searchParams.get("projectId") ?? "");
+
+  if (!mcpConfig) {
+    return badRequest("Tracker does not support MCP configuration");
+  }
+
   const info = getCliConfigInfo(cli);
   if (!info) {
     return NextResponse.json(
@@ -149,7 +172,31 @@ export async function POST(request: NextRequest) {
 
   try {
     const config = info.read();
-    const updated = info.addLinearMcp(config);
+    const serverKey = mcpConfig.name;
+
+    let serverValue: unknown;
+    if (mcpConfig.url) {
+      if (cli === "codex") {
+        serverValue = {
+          url: mcpConfig.url,
+          ...(mcpConfig.headers && Object.keys(mcpConfig.headers).length > 0 ? { headers: mcpConfig.headers } : {}),
+        };
+      } else {
+        serverValue = {
+          type: "url",
+          url: mcpConfig.url,
+          ...(mcpConfig.headers && Object.keys(mcpConfig.headers).length > 0 ? { headers: mcpConfig.headers } : {}),
+        };
+      }
+    } else {
+      serverValue = {
+        command: mcpConfig.command,
+        ...(mcpConfig.args ? { args: mcpConfig.args } : {}),
+        ...(mcpConfig.env && Object.keys(mcpConfig.env).length > 0 ? { env: mcpConfig.env } : {}),
+      };
+    }
+
+    const updated = info.addMcpServer(config, serverKey, serverValue);
     info.write(updated);
 
     return NextResponse.json({ ok: true });
@@ -159,11 +206,21 @@ export async function POST(request: NextRequest) {
   }
 }
 
-// DELETE: Remove Linear MCP config from a specific CLI
-export async function DELETE(request: NextRequest) {
-  const body = (await request.json()) as { cli: string };
+export async function DELETE(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const body = (await req.json()) as { cli: string };
   const { cli } = body;
 
+  const adapter = resolveAdapter(tracker);
+  const mcpConfig = adapter.getMcpConfig?.(req.nextUrl.searchParams.get("projectId") ?? "");
+
+  if (!mcpConfig) {
+    return badRequest("Tracker does not support MCP configuration");
+  }
+
   const info = getCliConfigInfo(cli);
   if (!info) {
     return NextResponse.json({ error: `Unsupported CLI: ${cli}` }, { status: 400 });
@@ -171,11 +228,11 @@ export async function DELETE(request: NextRequest) {
 
   try {
     const config = info.read();
-    const updated = info.removeLinearMcp(config);
+    const updated = info.removeMcpServer(config, mcpConfig.name);
     info.write(updated);
     return NextResponse.json({ ok: true });
   } catch (e) {
     const message = e instanceof Error ? e.message : "Failed to update config";
     return NextResponse.json({ error: message }, { status: 500 });
   }
-}
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/options/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const adapter = resolveAdapter(tracker);
+  try {
+    const [assignees, groups, statuses] = await Promise.allSettled([
+      adapter.listAssignees(projectId),
+      adapter.listGroups(projectId),
+      adapter.listStatuses(projectId),
+    ]);
+
+    return NextResponse.json({
+      assignees: assignees.status === "fulfilled" ? assignees.value : [],
+      groups: groups.status === "fulfilled" ? groups.value : [],
+      statuses: statuses.status === "fulfilled" ? statuses.value : [],
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to fetch options";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/{linear → trackers/[tracker]}/runs/[id]/route.ts

@@ -1,12 +1,14 @@
 import { NextRequest, NextResponse } from "next/server";
-import { getLinearRun, updateLinearRun, type LinearRunStatus } from "@/lib/linear-run-store";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { getTrackerRun, updateTrackerRun } from "@/lib/tracker/tracker-run-store";
+import type { TrackerRunStatus } from "@/lib/tracker/types";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
-type RouteContext = { params: Promise<{ id: string }> };
+type RouteContext = { params: Promise<{ tracker: string; id: string }> };
 
-interface UpdateLinearRunBody {
+interface UpdateTrackerRunBody {
   rootMessageId?: unknown;
   chatRunId?: unknown;
   status?: unknown;
@@ -18,7 +20,7 @@ function toOptionalString(value: unknown): string | null | undefined {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
-function toStatus(value: unknown): LinearRunStatus | undefined {
+function toStatus(value: unknown): TrackerRunStatus | undefined {
   if (
     value === "queued" ||
     value === "running" ||
@@ -31,19 +33,22 @@ function toStatus(value: unknown): LinearRunStatus | undefined {
   return undefined;
 }
 
-export async function GET(_request: NextRequest, context: RouteContext) {
+export async function GET(
+  _request: NextRequest,
+  context: RouteContext
+) {
   try {
     const { id } = await context.params;
-    const run = await getLinearRun(id);
+    const run = await getTrackerRun(id);
     if (!run) {
-      return NextResponse.json({ error: "Linear run not found" }, { status: 404 });
+      return NextResponse.json({ error: "Tracker run not found" }, { status: 404 });
     }
     return NextResponse.json({ run });
   } catch (error) {
-    console.error("Failed to load Linear run:", error);
+    console.error("Failed to load tracker run:", error);
     return NextResponse.json(
       {
-        error: "Failed to load Linear run",
+        error: "Failed to load tracker run",
         message: error instanceof Error ? error.message : String(error),
       },
       { status: 500 }
@@ -51,11 +56,14 @@ export async function GET(_request: NextRequest, context: RouteContext) {
   }
 }
 
-export async function PATCH(request: NextRequest, context: RouteContext) {
+export async function PATCH(
+  request: NextRequest,
+  context: RouteContext
+) {
   try {
     const { id } = await context.params;
-    const body = (await request.json().catch(() => ({}))) as UpdateLinearRunBody;
-    const run = await updateLinearRun({
+    const body = (await request.json().catch(() => ({}))) as UpdateTrackerRunBody;
+    const run = await updateTrackerRun({
       id,
       rootMessageId: toOptionalString(body.rootMessageId),
       chatRunId: toOptionalString(body.chatRunId),
@@ -64,18 +72,18 @@ export async function PATCH(request: NextRequest, context: RouteContext) {
     });
 
     if (!run) {
-      return NextResponse.json({ error: "Linear run not found" }, { status: 404 });
+      return NextResponse.json({ error: "Tracker run not found" }, { status: 404 });
     }
 
     return NextResponse.json({ run });
   } catch (error) {
-    console.error("Failed to update Linear run:", error);
+    console.error("Failed to update tracker run:", error);
     return NextResponse.json(
       {
-        error: "Failed to update Linear run",
+        error: "Failed to update tracker run",
         message: error instanceof Error ? error.message : String(error),
       },
       { status: 500 }
     );
   }
-}
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/runs/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { badRequest } from "@/lib/tracker/route-helpers";
+import { createTrackerRun, listTrackerRuns } from "@/lib/tracker/tracker-run-store";
+import type { TrackerRunMode } from "@/lib/tracker/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+function toOptionalString(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function toMode(value: unknown): TrackerRunMode {
+  return value === "scripted" ? "scripted" : "chat";
+}
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  try {
+    const issueId = req.nextUrl.searchParams.get("issueId")?.trim();
+    const projectId = req.nextUrl.searchParams.get("projectId")?.trim() ?? null;
+    const limitParam = req.nextUrl.searchParams.get("limit");
+    const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
+
+    if (!issueId) return badRequest("issueId is required");
+
+    const runs = await listTrackerRuns({
+      issueId,
+      projectId,
+      trackerType: tracker,
+      limit,
+    });
+    return NextResponse.json({ count: runs.length, runs });
+  } catch (error) {
+    console.error("Failed to list tracker runs:", error);
+    return NextResponse.json(
+      { error: "Failed to list tracker runs", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  try {
+    const body = (await req.json().catch(() => ({}))) as Record<string, unknown>;
+    const issueId = toOptionalString(body.issueId);
+    const issueIdentifier = toOptionalString(body.issueIdentifier);
+    const issueTitle = toOptionalString(body.issueTitle);
+    const issueStatus = toOptionalString(body.issueStatus);
+    const agentId = toOptionalString(body.agentId);
+    const agentName = toOptionalString(body.agentName);
+
+    if (!issueId || !issueIdentifier || !issueTitle || !issueStatus || !agentId || !agentName) {
+      return badRequest("issueId, issueIdentifier, issueTitle, issueStatus, agentId, and agentName are required");
+    }
+
+    const run = await createTrackerRun({
+      projectId: toOptionalString(body.projectId),
+      projectSlug: toOptionalString(body.projectSlug),
+      trackerType: tracker,
+      issueId,
+      issueIdentifier,
+      issueTitle,
+      issueStatus,
+      issueAssignee: toOptionalString(body.issueAssignee),
+      agentId,
+      agentName,
+      mode: toMode(body.mode),
+    });
+
+    return NextResponse.json({ run }, { status: 201 });
+  } catch (error) {
+    console.error("Failed to create tracker run:", error);
+    return NextResponse.json(
+      { error: "Failed to create tracker run", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}