@mndrk/agx 2.2.0 → 2.3.1

package/cloud-runtime/standalone/apps/local/hooks/useLinearParticipants.ts

@@ -0,0 +1,118 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import type { Participant } from "@/lib/types";
+
+export function useLinearParticipants(projectId?: string): {
+  participants: Participant[];
+  participantsLoaded: boolean;
+} {
+  const [participants, setParticipants] = useState<Participant[]>([]);
+  const [participantsLoaded, setParticipantsLoaded] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function loadParticipants() {
+      try {
+        const participantsResponse = await fetch("/api/participants");
+        const allParticipants = participantsResponse.ok
+          ? ((await participantsResponse.json()) as Participant[])
+          : [];
+
+        if (!projectId) {
+          if (!cancelled) {
+            setParticipants(allParticipants);
+            setParticipantsLoaded(true);
+          }
+          return;
+        }
+
+        // Check if the linear worker has a team configured
+        const workerParams = new URLSearchParams();
+        workerParams.set("projectId", projectId);
+        const workerResponse = await fetch(`/api/linear/worker?${workerParams}`).catch(() => null);
+        const workerData = workerResponse?.ok ? await workerResponse.json().catch(() => null) : null;
+        const workerTeamId: string | undefined = workerData?.job?.teamId || undefined;
+
+        if (workerTeamId) {
+          // Use the team's agents as participants
+          const teamAgentsResponse = await fetch(
+            `/api/projects/${encodeURIComponent(projectId)}/teams/${encodeURIComponent(workerTeamId)}/agents`
+          );
+          if (teamAgentsResponse.ok) {
+            const teamData = await teamAgentsResponse.json();
+            const teamAgentIds: string[] = Array.isArray(teamData.agents)
+              ? teamData.agents
+                  .sort((a: { routing_order?: number }, b: { routing_order?: number }) =>
+                    (a.routing_order ?? 0) - (b.routing_order ?? 0)
+                  )
+                  .map((agent: { agent_id?: string }) => agent.agent_id)
+                  .filter((value: unknown): value is string => typeof value === "string" && value.trim().length > 0)
+              : [];
+            if (teamAgentIds.length > 0) {
+              const teamOrderIndex = new Map(teamAgentIds.map((id, index) => [id, index]));
+              const teamParticipants = allParticipants
+                .filter((participant) => teamOrderIndex.has(participant.id))
+                .sort(
+                  (left, right) =>
+                    (teamOrderIndex.get(left.id) ?? Number.MAX_SAFE_INTEGER) -
+                    (teamOrderIndex.get(right.id) ?? Number.MAX_SAFE_INTEGER)
+                );
+              if (!cancelled && teamParticipants.length > 0) {
+                setParticipants(teamParticipants);
+                setParticipantsLoaded(true);
+                return;
+              }
+            }
+          }
+        }
+
+        // Fallback: use project agents
+        const projectAgentsResponse = await fetch(
+          `/api/projects/${encodeURIComponent(projectId)}/agents`
+        );
+        if (!projectAgentsResponse.ok) {
+          if (!cancelled) {
+            setParticipants(allParticipants);
+            setParticipantsLoaded(true);
+          }
+          return;
+        }
+
+        const projectData = await projectAgentsResponse.json();
+        const orderedAgentIds: string[] = Array.isArray(projectData.agents)
+          ? projectData.agents
+              .map((agent: { agent_id?: string }) => agent.agent_id)
+              .filter((value: unknown): value is string => typeof value === "string" && value.trim().length > 0)
+          : [];
+        const orderIndex = new Map(orderedAgentIds.map((id, index) => [id, index]));
+        const scopedParticipants = allParticipants
+          .filter((participant) => orderIndex.has(participant.id))
+          .sort(
+            (left, right) =>
+              (orderIndex.get(left.id) ?? Number.MAX_SAFE_INTEGER) -
+              (orderIndex.get(right.id) ?? Number.MAX_SAFE_INTEGER)
+          );
+
+        if (!cancelled) {
+          setParticipants(scopedParticipants);
+          setParticipantsLoaded(true);
+        }
+      } catch {
+        if (!cancelled) {
+          setParticipants([]);
+          setParticipantsLoaded(true);
+        }
+      }
+    }
+
+    void loadParticipants();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [projectId]);
+
+  return { participants, participantsLoaded };
+}

package/cloud-runtime/standalone/apps/local/hooks/usePromptJobs.ts

@@ -61,14 +61,16 @@ export function usePromptJobs(projectId?: string | null, options: UsePromptJobsO
   }, [fetchJobs]);
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const createJob = useCallback(async (input: any) => {
+  const createJob = useCallback(async (input: any): Promise<string | null> => {
     const res = await fetch('/api/prompt-jobs', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(input),
     });
-    if (res.ok) await fetchJobs();
-    return res.ok;
+    if (!res.ok) return null;
+    const { job } = await res.json();
+    await fetchJobs();
+    return job?.id ?? null;
   }, [fetchJobs]);
 
   const updateJob = useCallback(async (id: string, updates: Partial<PromptJob>) => {

package/cloud-runtime/standalone/apps/local/hooks/useSetupFlow.ts

@@ -3,99 +3,24 @@
 
 import { useState, useCallback } from "react";
 import { useRouter } from "next/navigation";
-import type { ProjectData } from "@/components/setup/ProjectStep";
-import type { SelectedTeam } from "@/components/setup/TeamsStep";
 
-export type SetupStep = 1 | 2 | 3 | 4;
-
-export interface SetupFlowState {
-  step: SetupStep;
-  project: ProjectData;
-  teams: SelectedTeam[];
-}
-
-function slugify(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "")
-    || "project";
-}
+export type SetupStep = 1 | 2;
 
 export function useSetupFlow() {
   const router = useRouter();
   const [step, setStep] = useState<SetupStep>(1);
-  const [project, setProject] = useState<ProjectData>({ name: "", description: "", folders: [] });
-  const [teams, setTeams] = useState<SelectedTeam[]>([]);
-  const [completing, setCompleting] = useState(false);
-  const [error, setError] = useState<string | null>(null);
 
   const goNext = useCallback(() => {
-    setStep((s) => Math.min(s + 1, 4) as SetupStep);
+    setStep((s) => Math.min(s + 1, 2) as SetupStep);
   }, []);
 
   const goBack = useCallback(() => {
     setStep((s) => Math.max(s - 1, 1) as SetupStep);
   }, []);
 
-  const complete = useCallback(async () => {
-    setCompleting(true);
-    setError(null);
-    try {
-      const slug = slugify(project.name);
-      const repos = project.folders.map((f) => ({ name: f.name, path: f.path }));
-
-      const projectRes = await fetch("/api/projects", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name: project.name, description: project.description || undefined, repos }),
-      });
-
-      if (!projectRes.ok) {
-        const data = await projectRes.json().catch(() => ({}));
-        throw new Error(data.error || "Failed to create project");
-      }
-
-      const { project: createdProject } = await projectRes.json();
-      const projectId = createdProject.id;
-
-      for (const team of teams) {
-        // Build agents array with per-agent provider/model (overrides inherit from team defaults)
-        const agents = team.agents.map((agent) => {
-          const override = team.agentOverrides?.find((o) => o.agentId === agent.id);
-          return {
-            roleId: agent.id,
-            provider: override?.provider || team.provider || undefined,
-            model: override?.model || team.model || undefined,
-          };
-        });
-
-        // Only include agents array if any have provider/model config
-        const hasConfig = agents.some((a) => a.provider || a.model);
-
-        await fetch(`/api/projects/${projectId}/teams`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            templateId: team.templateId,
-            variantId: team.variantId,
-            name: team.name,
-            ...(hasConfig ? { agents } : {}),
-          }),
-        });
-      }
-
-      router.push(`/projects/${createdProject.slug || slug}`);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Setup failed");
-    } finally {
-      setCompleting(false);
-    }
-  }, [project, teams, router]);
+  const finish = useCallback(() => {
+    router.push("/");
+  }, [router]);
 
-  return {
-    step, project, teams, completing, error,
-    setProject, setTeams,
-    goNext, goBack, complete,
-  };
+  return { step, goNext, goBack, finish };
 }

package/cloud-runtime/standalone/apps/local/lib/agent-participants.ts

@@ -17,7 +17,7 @@ export async function loadDbParticipants(): Promise<Participant[]> {
   return agents.map((agent) => ({
     id: agent.id,
     name: agent.name,
-    ...(agent.title ? { title: agent.title } : {}),
+    ...(agent.role ? { role: agent.role } : {}),
     provider: (agent.provider || "claude") as ChatProvider,
     model: agent.model || null,
     color: agent.color || "#6B7280",

package/cloud-runtime/standalone/apps/local/lib/agent-process-registry.ts

@@ -83,6 +83,40 @@ function getDb(): DatabaseSync {
   try {
     db.exec("ALTER TABLE agent_processes ADD COLUMN response_message_id TEXT NOT NULL DEFAULT ''");
   } catch { /* column already exists */ }
+  // Ensure joined tables exist so getAllEnriched() doesn't fail on a fresh DB
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      thread_id TEXT NOT NULL,
+      id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      participant_id TEXT,
+      content TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      PRIMARY KEY (thread_id, id)
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS linear_runs (
+      id TEXT PRIMARY KEY,
+      project_id TEXT,
+      project_slug TEXT,
+      issue_id TEXT NOT NULL,
+      issue_identifier TEXT NOT NULL,
+      issue_title TEXT NOT NULL,
+      issue_status TEXT NOT NULL,
+      issue_assignee TEXT,
+      thread_id TEXT NOT NULL,
+      root_message_id TEXT,
+      chat_run_id TEXT,
+      agent_id TEXT NOT NULL,
+      agent_name TEXT NOT NULL,
+      mode TEXT NOT NULL DEFAULT 'chat',
+      status TEXT NOT NULL DEFAULT 'queued',
+      error TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
   return db;
 }
 

package/cloud-runtime/standalone/apps/local/lib/db.ts

@@ -251,7 +251,7 @@ export interface Agent {
   id: string;
   user_id: string;
   name: string;
-  title?: string;
+  role?: string;
   style: AgentStyle;
   description?: string;
   voice?: string;
@@ -2338,7 +2338,7 @@ export async function createAgent(
   input: {
     id?: string;
     name: string;
-    title?: string;
+    role?: string;
     style: AgentStyle;
     description?: string;
     voice?: string;
@@ -2357,7 +2357,7 @@ export async function createAgent(
     description: input.description ?? null,
   };
   if (input.id !== undefined) payload.id = input.id;
-  if (input.title !== undefined) payload.title = input.title;
+  if (input.role !== undefined) payload.role = input.role;
   if (input.voice !== undefined) payload.voice = input.voice;
   if (input.seed !== undefined) payload.seed = input.seed;
   if (input.model !== undefined) payload.model = input.model;
@@ -2384,7 +2384,7 @@ export async function updateAgent(
   userId: string,
   input: {
     name?: string;
-    title?: string;
+    role?: string;
     style?: AgentStyle;
     description?: string;
     voice?: string;
@@ -2398,7 +2398,7 @@ export async function updateAgent(
 
   const updatePayload: Record<string, unknown> = { updated_at: new Date().toISOString() };
   if (input.name !== undefined) updatePayload.name = input.name;
-  if (input.title !== undefined) updatePayload.title = input.title;
+  if (input.role !== undefined) updatePayload.role = input.role;
   if (input.style !== undefined) updatePayload.style = input.style;
   if (input.description !== undefined) updatePayload.description = input.description;
   if (input.voice !== undefined) updatePayload.voice = input.voice;

package/cloud-runtime/standalone/apps/local/lib/linear-board-utils.ts

@@ -0,0 +1,9 @@
+export function agentAvatarUrl(id: string, color?: string, size = 20): string {
+  const bg = color ? color.replace("#", "") : "e2e8f0";
+  return `https://api.dicebear.com/9.x/bottts-neutral/svg?seed=${encodeURIComponent(id)}&size=${size}&backgroundColor=${bg}`;
+}
+
+export function openLinearIssueTab(issueUrl: string): void {
+  const opened = window.open(issueUrl, "_blank", "noopener,noreferrer");
+  opened?.focus();
+}

package/cloud-runtime/standalone/apps/local/lib/linear-run-status.ts

@@ -0,0 +1,88 @@
+import type { LinearRun } from "@/hooks/useLinearRuns";
+
+export type RunDisplayTone = LinearRun["status"] | "ready";
+
+export function formatRunStatus(status: LinearRun["status"]): string {
+  switch (status) {
+    case "queued":
+      return "queued";
+    case "running":
+      return "running";
+    case "success":
+      return "success";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return status;
+  }
+}
+
+export function getRunDisplayState(run: LinearRun): {
+  label: string;
+  tone: RunDisplayTone;
+} {
+  if (run.mode === "chat") {
+    switch (run.status) {
+      case "queued":
+        return { label: "starting", tone: "queued" };
+      case "running":
+        return { label: "thinking", tone: "running" };
+      case "success":
+        return { label: "ready", tone: "ready" };
+      case "failed":
+        return { label: "error", tone: "failed" };
+      case "cancelled":
+        return { label: "stopped", tone: "cancelled" };
+      default:
+        return { label: formatRunStatus(run.status), tone: run.status };
+    }
+  }
+
+  return { label: formatRunStatus(run.status), tone: run.status };
+}
+
+export function getRunTitle(run: LinearRun): string {
+  const title = run.sessionTitle?.trim();
+  if (title) {
+    return title;
+  }
+  return run.mode === "scripted" ? "Scripted session" : "Chat session";
+}
+
+export const STATUS_LABELS: Record<string, string> = {
+  "In Progress": "In Prog",
+  "In Review": "Review",
+  Backlog: "Backlog",
+  Todo: "Todo",
+  Done: "Done",
+  Cancelled: "Cancl.",
+};
+
+export const STATUS_BADGE_STYLES: Record<RunDisplayTone, string> = {
+  queued: "bg-amber-500/10 border-amber-500/20 text-amber-400",
+  running: "bg-yellow-500/10 border-yellow-500/20 text-yellow-400",
+  ready: "bg-sky-500/10 border-sky-500/20 text-sky-400",
+  success: "bg-emerald-500/10 border-emerald-500/20 text-emerald-400",
+  failed: "bg-red-500/10 border-red-500/20 text-red-400",
+  cancelled: "bg-zinc-500/10 border-zinc-500/20 text-zinc-400",
+};
+
+export const STATUS_DOT_COLORS: Record<RunDisplayTone, string> = {
+  queued: "bg-amber-400",
+  running: "bg-yellow-400",
+  ready: "bg-sky-400",
+  success: "bg-emerald-400",
+  failed: "bg-red-400",
+  cancelled: "bg-zinc-400",
+};
+
+export const STATUS_TEXT_COLORS: Record<RunDisplayTone, string> = {
+  queued: "text-amber-500",
+  running: "text-yellow-500",
+  ready: "text-sky-500",
+  success: "text-green-500",
+  failed: "text-red-500",
+  cancelled: "text-[var(--muted-foreground)]",
+};

package/cloud-runtime/standalone/apps/local/lib/linear-run-store.ts

@@ -485,17 +485,17 @@ export async function getIssueActiveAgents(
     const sql = hasProject
       ? `SELECT DISTINCT lr.issue_id, lr.agent_id, lr.agent_name
          FROM linear_runs lr
-         LEFT JOIN chat_runs cr ON cr.id = (
+         INNER JOIN chat_runs cr ON cr.id = (
            SELECT id FROM chat_runs WHERE thread_id = lr.thread_id ORDER BY updated_at DESC LIMIT 1
          )
-         WHERE (lr.status IN ('queued', 'running') OR cr.status IN ('queued', 'running'))
+         WHERE cr.status IN ('queued', 'running')
            AND lr.project_id = ?`
       : `SELECT DISTINCT lr.issue_id, lr.agent_id, lr.agent_name
          FROM linear_runs lr
-         LEFT JOIN chat_runs cr ON cr.id = (
+         INNER JOIN chat_runs cr ON cr.id = (
            SELECT id FROM chat_runs WHERE thread_id = lr.thread_id ORDER BY updated_at DESC LIMIT 1
          )
-         WHERE (lr.status IN ('queued', 'running') OR cr.status IN ('queued', 'running'))`;
+         WHERE cr.status IN ('queued', 'running')`;
 
     const rows = hasProject
       ? (db.prepare(sql).all(projectId!.trim()) as unknown as Array<{ issue_id: string; agent_id: string; agent_name: string }>)

package/cloud-runtime/standalone/apps/local/lib/sqlite-query-adapter.ts

@@ -191,7 +191,11 @@ function runMigrations(db: DatabaseSync): void {
     if (!agentColNames.has("model")) db.exec("ALTER TABLE agents ADD COLUMN model TEXT");
     if (!agentColNames.has("provider")) db.exec("ALTER TABLE agents ADD COLUMN provider TEXT");
     if (!agentColNames.has("color")) db.exec("ALTER TABLE agents ADD COLUMN color TEXT");
-    if (!agentColNames.has("title")) db.exec("ALTER TABLE agents ADD COLUMN title TEXT");
+    if (agentColNames.has("title") && !agentColNames.has("role")) {
+      db.exec("ALTER TABLE agents RENAME COLUMN title TO role");
+    } else if (!agentColNames.has("role")) {
+      db.exec("ALTER TABLE agents ADD COLUMN role TEXT");
+    }
   }
 
   db.exec(`