pragma-so 0.1.0

package/server/conversation/titleGenerator.ts

@@ -0,0 +1,106 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { homedir } from "node:os";
+import { DEFAULT_AGENT_ID } from "../db";
+import { getConversationAdapter } from "./adapters";
+import { getAdapterDefinition } from "./adapterRegistry";
+
+const TITLE_SYSTEM_PROMPT = [
+  "Generate a concise title (3-8 words) that summarizes the conversation.",
+  "Rules:",
+  "- No quotes around the title",
+  "- No punctuation at the end",
+  "- Use sentence case",
+  "- Output ONLY the title, nothing else",
+].join("\n");
+
+const TITLE_TIMEOUT_MS = 10_000;
+
+export async function generateTitle(
+  db: PGlite,
+  userMessage: string,
+  assistantMessage: string,
+): Promise<string> {
+  try {
+    const agent = await getAgentRow(db);
+    if (!agent) {
+      return deriveChatTitleFallback(userMessage, assistantMessage);
+    }
+
+    const harness = agent.harness;
+    const def = getAdapterDefinition(harness);
+    const modelId = def.titleModelId ?? agent.model_id;
+    const adapter = getConversationAdapter(harness);
+
+    const prompt = buildTitlePrompt(userMessage, assistantMessage);
+
+    const result = await Promise.race([
+      adapter.sendTurn({
+        prompt,
+        modelId,
+        sessionId: null,
+        cwd: homedir(),
+        mode: "chat",
+        onEvent: () => {},
+      }),
+      rejectAfterTimeout(TITLE_TIMEOUT_MS),
+    ]);
+
+    const title = result.finalText.trim();
+    if (title && title.length <= 100) {
+      return title;
+    }
+
+    return deriveChatTitleFallback(userMessage, assistantMessage);
+  } catch {
+    return deriveChatTitleFallback(userMessage, assistantMessage);
+  }
+}
+
+function buildTitlePrompt(userMessage: string, assistantMessage: string): string {
+  const parts = [TITLE_SYSTEM_PROMPT, "", "User message:", userMessage.slice(0, 500)];
+  if (assistantMessage) {
+    parts.push("", "Assistant response:", assistantMessage.slice(0, 500));
+  }
+  return parts.join("\n");
+}
+
+function rejectAfterTimeout(ms: number): Promise<never> {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error("Title generation timed out")), ms);
+  });
+}
+
+async function getAgentRow(
+  db: PGlite,
+): Promise<{ harness: string; model_id: string } | null> {
+  const result = await db.query<{ harness: string; model_id: string }>(
+    `SELECT harness, model_id FROM agents WHERE id = $1 LIMIT 1`,
+    [DEFAULT_AGENT_ID],
+  );
+  return result.rows[0] ?? null;
+}
+
+function deriveChatTitleFallback(userMessage: string, assistantMessage: string): string {
+  const userFirst = firstSentence(userMessage);
+  if (userFirst) {
+    return truncate(userFirst, 80);
+  }
+  const assistantFirst = firstSentence(assistantMessage);
+  if (assistantFirst) {
+    return truncate(assistantFirst, 80);
+  }
+  return "New chat";
+}
+
+function firstSentence(text: string): string {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return "";
+  const match = normalized.match(/(.+?[.!?])(?:\s|$)/);
+  return match?.[1]?.trim() ?? normalized;
+}
+
+function truncate(value: string, maxLength: number): string {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}

package/server/conversation/turnRunner.ts

@@ -0,0 +1,365 @@
+import { randomUUID } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { getConversationAdapter } from "./adapters";
+import { buildConversationHistoryBlock, buildPrompt } from "./prompts";
+import {
+  completeTurn,
+  ensureConversationSchema,
+  failTurn,
+  getThreadById,
+  getThreadMessages,
+  insertEvent,
+  insertMessage,
+  updateChatThreadMetadata,
+  updateThreadSession,
+} from "./store";
+import type { ConversationMode, HarnessId, ReasoningEffort, TaskStatus } from "./types";
+import { DEFAULT_AGENT_ID, getWorkspacePaths, openDatabase } from "../db";
+
+type TurnInput = {
+  workspaceName: string;
+  threadId: string;
+  turnId: string;
+  userMessageId: string;
+  isNewThread: boolean;
+  message: string;
+  mode: ConversationMode;
+  harness: HarnessId;
+  modelLabel: string;
+  modelId: string;
+  reasoningEffort?: ReasoningEffort;
+  requestedRecipientAgentId?: string | null;
+};
+
+type TurnRunnerCallbacks = {
+  apiUrl: string;
+  pragmaCliCommand: string;
+  onThreadUpdated?: (input: { workspaceName: string; threadId: string; source: string }) => void | Promise<void>;
+  onTaskStatusChanged?: (input: {
+    workspaceName: string;
+    taskId: string;
+    threadId: string;
+    status: string;
+    source: string;
+  }) => void | Promise<void>;
+  getAgentRow: (
+    db: Awaited<ReturnType<typeof openDatabase>>,
+    id: string,
+  ) => Promise<{ id: string; name: string; harness: HarnessId; model_label: string; model_id: string; agent_file: string | null } | null>;
+  listPlanWorkerCandidates: (
+    db: Awaited<ReturnType<typeof openDatabase>>,
+  ) => Promise<Array<{ id: string; name: string; description: string | null; harness: HarnessId; model_label: string }>>;
+  isDirectoryEmpty: (path: string) => Promise<boolean>;
+  getStoredPlanRecipientForTurn: (
+    db: Awaited<ReturnType<typeof openDatabase>>,
+    turnId: string,
+  ) => Promise<string | null>;
+  buildConversationAgentEnv: (input: {
+    apiUrl: string;
+    pragmaCliCommand: string;
+    workspaceName: string;
+    threadId: string;
+    turnId: string;
+    agentId: string;
+    taskId?: string | null;
+  }) => Record<string, string>;
+  emitTaskStatus: (workspaceName: string, taskId: string, status: TaskStatus, source: string) => void;
+};
+
+// Active AbortControllers keyed by turnId, so we can cancel in-progress turns
+const ACTIVE_TURN_ABORTS = new Map<string, AbortController>();
+
+export class TurnRunner {
+  private readonly callbacks: TurnRunnerCallbacks;
+
+  constructor(callbacks: TurnRunnerCallbacks) {
+    this.callbacks = callbacks;
+  }
+
+  /**
+   * Fire-and-forget: kicks off the turn in the background.
+   * Returns immediately. The turn runs to completion (or failure)
+   * independently of any client connection.
+   */
+  execute(input: TurnInput): void {
+    runTurn(input, this.callbacks).catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Turn runner failed for ${input.turnId}: ${message}`);
+    });
+  }
+
+  /**
+   * Abort an in-progress turn. Returns true if a turn was found and aborted.
+   */
+  abort(turnId: string): boolean {
+    const controller = ACTIVE_TURN_ABORTS.get(turnId);
+    if (controller) {
+      controller.abort();
+      return true;
+    }
+    return false;
+  }
+}
+
+async function runTurn(
+  input: TurnInput,
+  callbacks: TurnRunnerCallbacks,
+): Promise<void> {
+  const abortController = new AbortController();
+  ACTIVE_TURN_ABORTS.set(input.turnId, abortController);
+
+  const db = await openDatabase(input.workspaceName);
+  await ensureConversationSchema(db);
+  const paths = getWorkspacePaths(input.workspaceName);
+  const adapter = getConversationAdapter(input.harness);
+
+  const notifyThreadUpdated = async (source: string): Promise<void> => {
+    await callbacks.onThreadUpdated?.({
+      workspaceName: input.workspaceName,
+      threadId: input.threadId,
+      source,
+    });
+  };
+
+  const insertThreadEvent = async (payload: {
+    id: string;
+    threadId: string;
+    turnId: string | null;
+    eventName: string;
+    payload: unknown;
+  }): Promise<void> => {
+    await insertEvent(db, payload);
+    await notifyThreadUpdated(payload.eventName);
+  };
+
+  try {
+    const thread = await getThreadById(db, input.threadId);
+    if (!thread) {
+      throw new Error(`Thread not found: ${input.threadId}`);
+    }
+
+    // Emit thread_started event for new threads
+    if (input.isNewThread) {
+      const startedPayload = { thread_id: input.threadId };
+      await insertThreadEvent({
+        id: `evt_${randomUUID().slice(0, 12)}`,
+        threadId: input.threadId,
+        turnId: input.turnId,
+        eventName: "thread_started",
+        payload: startedPayload,
+      });
+    }
+
+    // Emit user_message_saved event
+    await insertThreadEvent({
+      id: `evt_${randomUUID().slice(0, 12)}`,
+      threadId: input.threadId,
+      turnId: input.turnId,
+      eventName: "user_message_saved",
+      payload: { message_id: input.userMessageId },
+    });
+
+    // Build prompt
+    let assistantText = "";
+    const planPromptCandidates =
+      input.mode === "plan" ? await callbacks.listPlanWorkerCandidates(db) : [];
+    const workspaceIsEmpty =
+      input.mode === "plan" ? await callbacks.isDirectoryEmpty(paths.codeDir) : false;
+    const chatCodeRepos =
+      input.mode === "chat"
+        ? (await readdir(paths.codeDir, { withFileTypes: true }).catch(() => []))
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name)
+            .sort()
+        : [];
+    // Fetch prior messages for conversation history fallback
+    const hasSessionId = Boolean(thread.harness_session_id);
+    let conversationHistory: Array<{ role: string; content: string }> | undefined;
+
+    if (!hasSessionId) {
+      // No session ID — full history fallback (last 40 messages)
+      const priorMessages = await getThreadMessages(db, input.threadId, 40);
+      if (priorMessages.length > 0) {
+        conversationHistory = priorMessages;
+      }
+    } else if (input.mode === "chat") {
+      // Session ID exists — include brief history as safety net (last 10 messages)
+      const priorMessages = await getThreadMessages(db, input.threadId, 10);
+      if (priorMessages.length > 0) {
+        conversationHistory = priorMessages;
+      }
+    }
+
+    let prompt = buildPrompt(input.mode, input.message, input.reasoningEffort, callbacks.pragmaCliCommand, {
+      planCandidates: planPromptCandidates.map((candidate) => ({
+        id: candidate.id,
+        name: candidate.name,
+        description: candidate.description,
+        harness: candidate.harness,
+        modelLabel: candidate.model_label,
+      })),
+      workspaceIsEmpty,
+      workspaceDir: paths.workspaceDir,
+      codeRepos: chatCodeRepos,
+      conversationHistory: hasSessionId ? conversationHistory : undefined,
+    });
+
+    // When no session ID, prepend full history block directly to the prompt
+    if (!hasSessionId && conversationHistory && conversationHistory.length > 0) {
+      const historyBlock = buildConversationHistoryBlock(conversationHistory);
+      if (historyBlock) {
+        prompt = historyBlock + "\n\n" + prompt;
+      }
+    }
+
+    const result = await adapter.sendTurn({
+      prompt,
+      modelId: input.modelId,
+      sessionId: thread.harness_session_id,
+      cwd: paths.codeDir,
+      env: callbacks.buildConversationAgentEnv({
+        apiUrl: callbacks.apiUrl,
+        pragmaCliCommand: callbacks.pragmaCliCommand,
+        workspaceName: input.workspaceName,
+        threadId: input.threadId,
+        turnId: input.turnId,
+        agentId: DEFAULT_AGENT_ID,
+        taskId: thread.task_id,
+      }),
+      mode: input.mode,
+      reasoningEffort: input.reasoningEffort,
+      abortSignal: abortController.signal,
+      onEvent: async (event) => {
+        if (abortController.signal.aborted) return;
+        if (event.type === "assistant_text") {
+          assistantText = assistantText ? `${assistantText}\n${event.delta}` : event.delta;
+          await insertThreadEvent({
+            id: `evt_${randomUUID().slice(0, 12)}`,
+            threadId: input.threadId,
+            turnId: input.turnId,
+            eventName: "assistant_text",
+            payload: event,
+          });
+          return;
+        }
+
+        await insertThreadEvent({
+          id: `evt_${randomUUID().slice(0, 12)}`,
+          threadId: input.threadId,
+          turnId: input.turnId,
+          eventName: "tool_event",
+          payload: event,
+        });
+      },
+    });
+
+    if (result.aborted) {
+      const partialText = (result.finalText || assistantText || "").trim();
+      await failTurn(db, input.turnId, "Turn aborted.");
+      if (partialText) {
+        await insertMessage(db, {
+          id: `msg_${randomUUID().slice(0, 12)}`,
+          threadId: input.threadId,
+          turnId: input.turnId,
+          role: "assistant",
+          content: partialText,
+        });
+      }
+      await insertThreadEvent({
+        id: `evt_${randomUUID().slice(0, 12)}`,
+        threadId: input.threadId,
+        turnId: input.turnId,
+        eventName: "turn_failed",
+        payload: { turn_id: input.turnId, reason: "aborted" },
+      });
+      return;
+    }
+
+    const finalAssistantText = (result.finalText || assistantText || "").trim();
+    const assistantMessageId = `msg_${randomUUID().slice(0, 12)}`;
+    const selectedPlanRecipientAgentId =
+      input.mode === "plan" ? await callbacks.getStoredPlanRecipientForTurn(db, input.turnId) : null;
+
+    await completeTurn(db, {
+      turnId: input.turnId,
+      assistantMessage: finalAssistantText,
+      selectedAgentId: selectedPlanRecipientAgentId,
+      selectionStatus: input.mode === "plan"
+        ? (selectedPlanRecipientAgentId ? "auto_selected" : "recipient_required")
+        : null,
+    });
+
+    await insertMessage(db, {
+      id: assistantMessageId,
+      threadId: input.threadId,
+      turnId: input.turnId,
+      role: "assistant",
+      content: finalAssistantText,
+    });
+
+    // Transition task from planning → planned when plan turn completes,
+    // but only if the agent didn't ask a question during this turn.
+    if (input.mode === "plan" && thread.task_id) {
+      const currentTask = await db.query<{ status: string }>(
+        `SELECT status FROM tasks WHERE id = $1 LIMIT 1`,
+        [thread.task_id],
+      );
+      const currentStatus = currentTask.rows[0]?.status;
+      if (currentStatus !== "waiting_for_question_response") {
+        if (selectedPlanRecipientAgentId) {
+          await db.query(
+            `UPDATE tasks SET status = 'planned', plan = $2, assigned_to = $3 WHERE id = $1`,
+            [thread.task_id, finalAssistantText, selectedPlanRecipientAgentId],
+          );
+        } else {
+          await db.query(
+            `UPDATE tasks SET status = 'planned', plan = $2 WHERE id = $1`,
+            [thread.task_id, finalAssistantText],
+          );
+        }
+        callbacks.emitTaskStatus(input.workspaceName, thread.task_id, "planned", "plan_completed");
+      }
+    }
+
+    if (input.mode === "chat") {
+      // Title generation is handled upstream (before the turn starts) so only
+      // update the lastMessageAt timestamp here.
+      await updateChatThreadMetadata(db, {
+        threadId: input.threadId,
+        lastMessageAt: new Date().toISOString(),
+      });
+    }
+
+    await updateThreadSession(db, {
+      threadId: input.threadId,
+      sessionId: result.sessionId,
+    });
+
+    const turnCompletedPayload = {
+      turn_id: input.turnId,
+      assistant_message_id: assistantMessageId,
+    };
+
+    await insertThreadEvent({
+      id: `evt_${randomUUID().slice(0, 12)}`,
+      threadId: input.threadId,
+      turnId: input.turnId,
+      eventName: "turn_completed",
+      payload: turnCompletedPayload,
+    });
+  } catch (error: unknown) {
+    const messageText = error instanceof Error ? error.message : String(error);
+
+    await failTurn(db, input.turnId, messageText);
+    await insertThreadEvent({
+      id: `evt_${randomUUID().slice(0, 12)}`,
+      threadId: input.threadId,
+      turnId: input.turnId,
+      eventName: "error",
+      payload: { code: "TURN_ERROR", message: messageText },
+    });
+  } finally {
+    ACTIVE_TURN_ABORTS.delete(input.turnId);
+    await db.close();
+  }
+}

package/server/conversation/types.ts

@@ -0,0 +1,134 @@
+export type ConversationMode = "chat" | "plan" | "execute";
+
+export type HarnessId = string;
+export type ReasoningEffort = "low" | "medium" | "high" | "extra_high";
+
+export const TASK_STATUS_VALUES = [
+  "planning",
+  "planned",
+  "queued",
+  "orchestrating",
+  "running",
+  "waiting_for_recipient",
+  "waiting_for_question_response",
+  "waiting_for_help_response",
+  "pending_review",
+  "merging",
+  "needs_fix",
+  "completed",
+  "failed",
+  "cancelled",
+] as const;
+
+export type TaskStatus = (typeof TASK_STATUS_VALUES)[number];
+
+const TASK_STATUS_SET = new Set<string>(TASK_STATUS_VALUES);
+
+export function isTaskStatus(value: unknown): value is TaskStatus {
+  return typeof value === "string" && TASK_STATUS_SET.has(value);
+}
+
+export type ConversationStatus = "open" | "closed";
+
+export type ConversationThread = {
+  id: string;
+  mode: ConversationMode;
+  status: ConversationStatus;
+  harness: HarnessId;
+  model_label: string;
+  model_id: string;
+  harness_session_id: string | null;
+  task_id: string | null;
+  source_thread_id: string | null;
+  chat_title?: string | null;
+  chat_preview?: string | null;
+  chat_last_message_at?: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export type ChatThreadListItem = {
+  id: string;
+  chat_title: string | null;
+  chat_preview: string | null;
+  status: ConversationStatus;
+  updated_at: string;
+  chat_last_message_at: string | null;
+  latest_turn_status: "running" | "completed" | "failed" | null;
+};
+
+export type OpenPlanThreadListItem = {
+  id: string;
+  status: ConversationStatus;
+  created_at: string;
+  updated_at: string;
+  task_id: string | null;
+  latest_plan_assistant_message: string | null;
+  first_user_message: string | null;
+  has_completed_plan_turn: boolean;
+  latest_turn_status: "running" | "completed" | "failed" | null;
+  task_status: string | null;
+};
+
+export type ConversationTurn = {
+  id: string;
+  thread_id: string;
+  mode: ConversationMode;
+  user_message: string;
+  assistant_message: string | null;
+  reasoning_effort: ReasoningEffort | null;
+  requested_recipient_agent_id: string | null;
+  selected_agent_id: string | null;
+  orchestrator_agent_id: string | null;
+  worker_session_id: string | null;
+  selection_status: "auto_selected" | "manual_selected" | "recipient_required" | "invalid" | null;
+  status: "running" | "completed" | "failed";
+  created_at: string;
+  completed_at: string | null;
+};
+
+export type ConversationMessage = {
+  id: string;
+  thread_id: string;
+  turn_id: string | null;
+  role: "user" | "assistant" | "system";
+  content: string;
+  created_at: string;
+};
+
+export type ConversationEvent = {
+  id: string;
+  seq?: number;
+  thread_id: string;
+  turn_id: string | null;
+  event_name: string;
+  payload_json: string;
+  created_at: string;
+};
+
+export type AdapterEvent =
+  | { type: "assistant_text"; delta: string }
+  | { type: "tool_event"; name: string; payload: Record<string, unknown> | string | null };
+
+export type AdapterSendTurnInput = {
+  prompt: string;
+  modelId: string;
+  sessionId: string | null;
+  cwd: string;
+  env?: Record<string, string>;
+  mode: ConversationMode;
+  reasoningEffort?: ReasoningEffort;
+  onEvent: (event: AdapterEvent) => void | Promise<void>;
+  abortSignal?: AbortSignal;
+};
+
+export type AdapterSendTurnResult = {
+  sessionId: string;
+  finalText: string;
+  rawSummary?: string;
+  aborted?: boolean;
+};
+
+export interface ConversationAdapter {
+  sendTurn(input: AdapterSendTurnInput): Promise<AdapterSendTurnResult>;
+}