conductor-oss 0.2.15 → 0.2.16

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModelsShared.ts

@@ -0,0 +1,65 @@
+import type {
+  AgentModelAccess,
+  AgentModelOption,
+  AgentReasoningOption,
+  SupportedModelAgent,
+} from "@conductor-oss/core/types";
+
+export interface RuntimeAgentModelCatalog {
+  agent: SupportedModelAgent;
+  customModelPlaceholder: string;
+  defaultModelByAccess: Partial<Record<AgentModelAccess, string>>;
+  modelsByAccess: Partial<Record<AgentModelAccess, AgentModelOption[]>>;
+  defaultReasoningByAccess?: Partial<Record<AgentModelAccess, string>>;
+  reasoningOptionsByAccess?: Partial<Record<AgentModelAccess, AgentReasoningOption[]>>;
+  defaultReasoningByModel?: Record<string, string>;
+  reasoningOptionsByModel?: Record<string, AgentReasoningOption[]>;
+}
+
+export function getRuntimeCatalogModelsForAccess(
+  catalog: RuntimeAgentModelCatalog | null | undefined,
+  access: string | null | undefined,
+): AgentModelOption[] {
+  if (!catalog || !access) return [];
+  return catalog.modelsByAccess[access as AgentModelAccess] ?? [];
+}
+
+export function getRuntimeCatalogDefaultModelForAccess(
+  catalog: RuntimeAgentModelCatalog | null | undefined,
+  access: string | null | undefined,
+): string | null {
+  if (!catalog || !access) return null;
+  return catalog.defaultModelByAccess[access as AgentModelAccess] ?? null;
+}
+
+export function getRuntimeCatalogReasoningOptions(
+  catalog: RuntimeAgentModelCatalog | null | undefined,
+  model: string | null | undefined,
+  access: string | null | undefined,
+): AgentReasoningOption[] {
+  if (!catalog) return [];
+
+  const normalizedModel = model?.trim();
+  if (normalizedModel && catalog.reasoningOptionsByModel?.[normalizedModel]?.length) {
+    return catalog.reasoningOptionsByModel[normalizedModel] ?? [];
+  }
+
+  if (!access) return [];
+  return catalog.reasoningOptionsByAccess?.[access as AgentModelAccess] ?? [];
+}
+
+export function getRuntimeCatalogDefaultReasoning(
+  catalog: RuntimeAgentModelCatalog | null | undefined,
+  model: string | null | undefined,
+  access: string | null | undefined,
+): string | null {
+  if (!catalog) return null;
+
+  const normalizedModel = model?.trim();
+  if (normalizedModel && catalog.defaultReasoningByModel?.[normalizedModel]) {
+    return catalog.defaultReasoningByModel[normalizedModel] ?? null;
+  }
+
+  if (!access) return null;
+  return catalog.defaultReasoningByAccess?.[access as AgentModelAccess] ?? null;
+}

package/web/.next/standalone/packages/web/src/lib/serialize.ts

@@ -0,0 +1,128 @@
+// @ts-nocheck
+/**
+ * Core Session -> DashboardSession serialization.
+ *
+ * Converts core types (Date objects, PRInfo) into dashboard types
+ * (string dates, flattened DashboardPR) suitable for JSON serialization.
+ */
+
+import type { Session, PRInfo } from "@conductor-oss/core/types";
+import type { DashboardSession, DashboardPR, DashboardStats } from "./types";
+
+export function normalizeSummary(summary: string | null | undefined): string | null {
+  if (!summary) return null;
+  const cleaned = summary.replace(/\s+/g, " ").trim();
+  if (!cleaned) return null;
+  if (cleaned.startsWith("You are an AI coding agent managed by Conductor")) return null;
+  if (/^(Codex|Claude)\s+session\s*\(/i.test(cleaned)) return null;
+  return cleaned;
+}
+
+function buildPRSummary(session: Session): string | null {
+  if (!session.pr) return null;
+  const meta = session.metadata;
+  const title = session.pr.title || meta["prTitle"] || "";
+  const state = meta["prState"] ?? "open";
+  const ciStatus = meta["ciStatus"] ?? "none";
+  const reviewDecision = meta["reviewDecision"] ?? "none";
+  let text = `PR #${session.pr.number}${title ? ` — ${title}` : ""} · state: ${state} · CI: ${ciStatus} · review: ${reviewDecision}`;
+
+  if (meta["mergeReadiness"]) {
+    try {
+      const readiness = JSON.parse(meta["mergeReadiness"]) as { blockers?: string[] };
+      if (Array.isArray(readiness.blockers) && readiness.blockers.length > 0) {
+        text += ` · blockers: ${readiness.blockers.join("; ")}`;
+      }
+    } catch {
+      // ignore malformed mergeReadiness
+    }
+  }
+  return text;
+}
+
+/** Convert a core Session to a DashboardSession. */
+export function sessionToDashboard(session: Session): DashboardSession {
+  const summary =
+    normalizeSummary(session.agentInfo?.summary ?? session.metadata["summary"] ?? null)
+    ?? buildPRSummary(session)
+    ?? null;
+
+  return {
+    id: session.id,
+    projectId: session.projectId,
+    status: session.status,
+    activity: session.activity,
+    branch: session.branch,
+    issueId: session.issueId,
+    summary,
+    createdAt: session.createdAt.toISOString(),
+    lastActivityAt: session.lastActivityAt.toISOString(),
+    pr: session.pr ? prToDashboard(session.pr, session.metadata) : null,
+    metadata: session.metadata,
+  };
+}
+
+/** Convert a core PRInfo to a DashboardPR, reading persisted data from metadata. */
+function prToDashboard(pr: PRInfo, metadata: Record<string, string>): DashboardPR {
+  // Parse merge readiness from JSON-serialized metadata
+  let mergeability: DashboardPR["mergeability"] = {
+    mergeable: false,
+    ciPassing: false,
+    approved: false,
+    noConflicts: true,
+    blockers: [],
+  };
+  if (metadata["mergeReadiness"]) {
+    try {
+      const parsed = JSON.parse(metadata["mergeReadiness"]) as Record<string, unknown>;
+      mergeability = {
+        mergeable: Boolean(parsed["mergeable"]),
+        ciPassing: Boolean(parsed["ciPassing"]),
+        approved: Boolean(parsed["approved"]),
+        noConflicts: parsed["noConflicts"] !== false,
+        blockers: Array.isArray(parsed["blockers"])
+          ? (parsed["blockers"] as string[])
+          : [],
+      };
+    } catch {
+      // Invalid JSON — use defaults
+    }
+  }
+
+  const title = pr.title || metadata["prTitle"] || "";
+  const branch = pr.branch || metadata["prHeadRef"] || "";
+  const baseBranch = pr.baseBranch || metadata["prBaseRef"] || "";
+  const isDraft =
+    pr.isDraft || metadata["prDraft"] === "1" || metadata["prDraft"] === "true";
+
+  return {
+    number: pr.number,
+    url: pr.url,
+    title,
+    branch,
+    baseBranch,
+    isDraft,
+    state: (metadata["prState"] as DashboardPR["state"]) || "open",
+    ciStatus: (metadata["ciStatus"] as DashboardPR["ciStatus"]) || "none",
+    reviewDecision: (metadata["reviewDecision"] as DashboardPR["reviewDecision"]) || "none",
+    mergeability,
+    previewUrl: metadata["previewUrl"] ?? null,
+  };
+}
+
+/** Compute aggregate stats from dashboard sessions. */
+export function computeStats(sessions: DashboardSession[]): DashboardStats {
+  return {
+    totalSessions: sessions.length,
+    workingSessions: sessions.filter((s) => s.activity === "active").length,
+    openPRs: sessions.filter((s) => s.pr?.state === "open").length,
+    needsAttention: sessions.filter(
+      (s) =>
+        s.status === "needs_input" ||
+        s.status === "stuck" ||
+        s.status === "errored" ||
+        s.activity === "waiting_input" ||
+        s.activity === "blocked"
+    ).length,
+  };
+}

package/web/.next/standalone/packages/web/src/lib/services.ts

@@ -0,0 +1,319 @@
+/**
+ * Server-side singleton for core services.
+ *
+ * Lazily initializes config, plugin registry, and session manager.
+ * Cached in globalThis to survive Next.js HMR reloads in development.
+ */
+
+import type {
+  OrchestratorConfig,
+  PluginRegistry,
+  SessionManager,
+} from "@conductor-oss/core/types";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve, join } from "node:path";
+
+export interface Services {
+  config: OrchestratorConfig;
+  registry: PluginRegistry;
+  sessionManager: SessionManager;
+}
+
+const BUILTIN_PLUGIN_IMPORTS: Record<string, () => Promise<unknown>> = {
+  "@conductor-oss/plugin-runtime-tmux": () => import("@conductor-oss/plugin-runtime-tmux"),
+  "@conductor-oss/plugin-agent-claude-code": () => import("@conductor-oss/plugin-agent-claude-code"),
+  "@conductor-oss/plugin-agent-codex": () => import("@conductor-oss/plugin-agent-codex"),
+  "@conductor-oss/plugin-agent-gemini": () => import("@conductor-oss/plugin-agent-gemini"),
+  "@conductor-oss/plugin-agent-amp": () => import("@conductor-oss/plugin-agent-amp"),
+  "@conductor-oss/plugin-agent-cursor-cli": () => import("@conductor-oss/plugin-agent-cursor-cli"),
+  "@conductor-oss/plugin-agent-opencode": () => import("@conductor-oss/plugin-agent-opencode"),
+  "@conductor-oss/plugin-agent-droid": () => import("@conductor-oss/plugin-agent-droid"),
+  "@conductor-oss/plugin-agent-qwen-code": () => import("@conductor-oss/plugin-agent-qwen-code"),
+  "@conductor-oss/plugin-agent-ccr": () => import("@conductor-oss/plugin-agent-ccr"),
+  "@conductor-oss/plugin-agent-github-copilot": () => import("@conductor-oss/plugin-agent-github-copilot"),
+  "@conductor-oss/plugin-workspace-worktree": () => import("@conductor-oss/plugin-workspace-worktree"),
+  "@conductor-oss/plugin-tracker-github": () => import("@conductor-oss/plugin-tracker-github"),
+  "@conductor-oss/plugin-scm-github": () => import("@conductor-oss/plugin-scm-github"),
+  "@conductor-oss/plugin-notifier-desktop": () => import("@conductor-oss/plugin-notifier-desktop"),
+  "@conductor-oss/plugin-notifier-discord": () => import("@conductor-oss/plugin-notifier-discord"),
+  "@conductor-oss/plugin-terminal-web": () => import("@conductor-oss/plugin-terminal-web"),
+};
+
+// Cache in globalThis for Next.js HMR stability
+const globalForServices = globalThis as typeof globalThis & {
+  _conductorServices?: Services;
+  _conductorServicesInit?: Promise<Services>;
+  _conductorServicesConfigPath?: string;
+  _conductorServicesConfigMtimeMs?: number;
+};
+
+function expandHomePath(value: string): string {
+  if (value.startsWith("~/")) {
+    return resolve(homedir(), value.slice(2));
+  }
+  return value;
+}
+
+function normalizeConfigPath(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const expanded = expandHomePath(value.trim());
+  return expanded ? resolve(expanded) : undefined;
+}
+
+function resolveWorkspaceConfigPath(workspacePath: string): string | undefined {
+  const configFileNames = ["conductor.yaml", "conductor.yml"] as const;
+  for (const configFile of configFileNames) {
+    const directConfigPath = resolve(workspacePath, configFile);
+    if (existsSync(directConfigPath)) {
+      return directConfigPath;
+    }
+  }
+  return undefined;
+}
+
+function findConfigFromConductorMetadata(): string | undefined {
+  const conductorDir = resolve(homedir(), ".conductor");
+  if (!existsSync(conductorDir)) {
+    return undefined;
+  }
+
+  let best: {
+    path: string;
+    activeSessionCount: number;
+    latestSessionChange: number;
+  } | null = null;
+
+  try {
+    for (const entry of readdirSync(conductorDir)) {
+      const baseDir = join(conductorDir, entry);
+      const originPath = join(baseDir, ".origin");
+      if (!existsSync(originPath)) continue;
+
+      let resolvedOrigin = "";
+      try {
+        resolvedOrigin = resolve(readFileSync(originPath, "utf8").trim());
+      } catch {
+        continue;
+      }
+      if (!resolvedOrigin) continue;
+
+      let configPath = resolveWorkspaceConfigPath(resolvedOrigin);
+      if (!configPath && [".yaml", ".yml"].some((ext) => resolvedOrigin.endsWith(ext))) {
+        try {
+          if (statSync(resolvedOrigin).isFile()) {
+            configPath = resolvedOrigin;
+          }
+        } catch {
+          continue;
+        }
+      }
+
+      if (!configPath) continue;
+
+      const sessionsDir = join(baseDir, "sessions");
+      let activeSessionCount = 0;
+      let latestSessionChange = 0;
+
+      if (existsSync(sessionsDir)) {
+        try {
+          for (const item of readdirSync(sessionsDir)) {
+            if (item === "archive" || item.startsWith(".")) continue;
+
+            const itemPath = join(sessionsDir, item);
+            const stats = statSync(itemPath);
+            if (!stats.isFile()) continue;
+
+            activeSessionCount += 1;
+            if (stats.mtimeMs > latestSessionChange) {
+              latestSessionChange = stats.mtimeMs;
+            }
+          }
+        } catch {
+          // Ignore broken session snapshots.
+        }
+      }
+
+      const candidate = {
+        path: configPath,
+        activeSessionCount,
+        latestSessionChange,
+      };
+
+      if (
+        !best ||
+        candidate.activeSessionCount > best.activeSessionCount ||
+        (candidate.activeSessionCount === best.activeSessionCount &&
+          candidate.latestSessionChange > best.latestSessionChange)
+      ) {
+        best = candidate;
+      }
+    }
+  } catch {
+    return undefined;
+  }
+
+  return best?.path;
+}
+
+function findConfigFromWorkspace(workspace?: string): string | undefined {
+  if (!workspace) return undefined;
+
+  const workspacePath = normalizeConfigPath(workspace);
+  if (!workspacePath) return undefined;
+
+  const directConfigPath = resolveWorkspaceConfigPath(workspacePath);
+  if (directConfigPath) {
+    return directConfigPath;
+  }
+
+  const conductorDir = resolve(homedir(), ".conductor");
+  if (!existsSync(conductorDir)) {
+    return undefined;
+  }
+
+  try {
+    for (const entry of readdirSync(conductorDir)) {
+      const originPath = join(conductorDir, entry, ".origin");
+      if (!existsSync(originPath)) continue;
+
+      const stat = statSync(originPath);
+      if (!stat.isFile()) continue;
+
+      const resolvedOrigin = resolve(readFileSync(originPath, "utf8").trim());
+      if (resolvedOrigin !== workspacePath) continue;
+
+      const originWorkspaceConfig = resolveWorkspaceConfigPath(resolvedOrigin);
+      if (originWorkspaceConfig) {
+        return originWorkspaceConfig;
+      }
+
+      if (
+        existsSync(resolvedOrigin) && [
+          ".yaml",
+          ".yml",
+        ].some((ext) => resolvedOrigin.endsWith(ext)) &&
+        statSync(resolvedOrigin).isFile()
+      ) {
+        return resolvedOrigin;
+      }
+    }
+  } catch {
+    // Ignore workspace metadata lookup failures.
+  }
+
+  return undefined;
+}
+
+function getConfigStateFromEnv(): { path: string | undefined } {
+  const envConfigPath = normalizeConfigPath(process.env["CO_CONFIG_PATH"]);
+  const workspaceConfigPath = findConfigFromWorkspace(process.env["CONDUCTOR_WORKSPACE"]);
+  const homeWorkspaceConfigCandidate = normalizeConfigPath(`${homedir()}/.openclaw/workspace/conductor.yaml`);
+  const homeWorkspaceConfig = homeWorkspaceConfigCandidate && existsSync(homeWorkspaceConfigCandidate)
+    ? homeWorkspaceConfigCandidate
+    : undefined;
+
+  return {
+    path: envConfigPath ||
+      workspaceConfigPath ||
+      homeWorkspaceConfig ||
+      findConfigFromConductorMetadata(),
+  };
+}
+
+function getConfigMtimeMs(configPath: string | undefined): number | undefined {
+  if (!configPath) return undefined;
+  try {
+    const stats = statSync(configPath);
+    return stats.mtimeMs;
+  } catch {
+    return undefined;
+  }
+}
+
+function clearCachedServices(reason = "stale config"): void {
+  globalForServices._conductorServices = undefined;
+  globalForServices._conductorServicesInit = undefined;
+  globalForServices._conductorServicesConfigPath = undefined;
+  globalForServices._conductorServicesConfigMtimeMs = undefined;
+  console.info(`[conductor:web] service cache reset (${reason})`);
+}
+
+export function invalidateServicesCache(reason = "manual invalidation"): void {
+  clearCachedServices(reason);
+}
+
+/** Get (or lazily initialize) the core services singleton. */
+export function getServices(): Promise<Services> {
+  const configState = getConfigStateFromEnv();
+  const normalizedConfigPath = configState.path ? normalizeConfigPath(configState.path) : undefined;
+  const configMtimeMs = getConfigMtimeMs(normalizedConfigPath);
+
+  if (globalForServices._conductorServices) {
+    if (normalizedConfigPath !== globalForServices._conductorServicesConfigPath) {
+      clearCachedServices("configuration path changed");
+    } else if (
+      normalizedConfigPath &&
+      configMtimeMs !== undefined &&
+      globalForServices._conductorServicesConfigMtimeMs !== undefined &&
+      configMtimeMs !== globalForServices._conductorServicesConfigMtimeMs
+    ) {
+      clearCachedServices("configuration changed on disk");
+    }
+  }
+
+  if (globalForServices._conductorServices) {
+    return Promise.resolve(globalForServices._conductorServices);
+  }
+  if (!globalForServices._conductorServicesInit) {
+    globalForServices._conductorServicesInit = initServices().catch((err) => {
+      // Clear cached promise so the next call retries
+      globalForServices._conductorServicesInit = undefined;
+      throw err;
+    });
+  }
+  return globalForServices._conductorServicesInit;
+}
+
+async function initServices(): Promise<Services> {
+  // Dynamic import to avoid bundling issues with server-only modules.
+  // These will be provided by the core package once plugins are wired.
+  // For now, we attempt to import from core's main entry.
+  const core = await import("@conductor-oss/core");
+
+  const loadConfig = core.loadConfig as ((configPath?: string) => OrchestratorConfig) | undefined;
+  const createPluginRegistry = core.createPluginRegistry as (() => PluginRegistry) | undefined;
+  const createSessionManager = core.createSessionManager as
+    | ((deps: { config: OrchestratorConfig; registry: PluginRegistry }) => SessionManager)
+    | undefined;
+
+  if (!loadConfig || !createPluginRegistry || !createSessionManager) {
+    throw new Error(
+      "Core package does not export required functions (loadConfig, createPluginRegistry, createSessionManager). " +
+      "Ensure @conductor-oss/core is built and exports these."
+    );
+  }
+
+  const envConfig = getConfigStateFromEnv();
+  const configPath = envConfig.path ? normalizeConfigPath(envConfig.path) : undefined;
+  const config = configPath ? loadConfig(configPath) : loadConfig();
+  const registry = createPluginRegistry();
+
+  // Load built-in plugins with config for proper initialization
+  if (typeof registry.loadBuiltins === "function") {
+    await registry.loadBuiltins(config, async (pkg) => {
+      const importer = BUILTIN_PLUGIN_IMPORTS[pkg];
+      if (importer) return importer();
+      return import(pkg);
+    });
+  }
+
+  const sessionManager = createSessionManager({ config, registry });
+
+  const services: Services = { config, registry, sessionManager };
+  globalForServices._conductorServices = services;
+  const loadedConfigPath = normalizeConfigPath(config.configPath);
+  globalForServices._conductorServicesConfigPath = loadedConfigPath ?? config.configPath;
+  globalForServices._conductorServicesConfigMtimeMs = getConfigMtimeMs(loadedConfigPath);
+  return services;
+}

package/web/.next/standalone/packages/web/src/lib/types.ts

@@ -0,0 +1,182 @@
+/**
+ * Dashboard-specific types for the Conductor v2 web UI.
+ *
+ * Core types (SessionStatus, ActivityState, etc.) are re-exported from @conductor-oss/core.
+ * Dashboard types flatten/extend core types for JSON-safe client-side rendering.
+ */
+
+// Inlined from @conductor-oss/core/types to avoid client-side bundle issues
+// with serverExternalPackages excluding the core package from client builds.
+// Using string to support all core + legacy + dashboard status values without conflicts
+export type SessionStatus = string;
+export type ActivityState =
+  | "active" | "ready" | "idle" | "waiting_input" | "blocked" | "exited";
+export type CIStatus = "pending" | "passing" | "failing" | "none";
+export type ReviewDecision = "approved" | "changes_requested" | "pending" | "none";
+export interface MergeReadiness {
+  mergeable: boolean;
+  ciPassing: boolean;
+  approved: boolean;
+  noConflicts: boolean;
+  blockers: string[];
+}
+export type PRState = "open" | "merged" | "closed";
+
+/**
+ * Attention zone priority level, ordered by human action urgency:
+ *
+ * 1. merge   -- PR approved + CI green. One click to clear.
+ * 2. respond -- Agent waiting for human input. Quick unblock.
+ * 3. review  -- CI failed, changes requested. Needs investigation.
+ * 4. pending -- Waiting on external (reviewer, CI). Nothing to do now.
+ * 5. working -- Agents doing their thing. Don't interrupt.
+ * 6. done    -- Merged or terminated. Archive.
+ */
+export type AttentionLevel =
+  | "merge"
+  | "respond"
+  | "review"
+  | "pending"
+  | "working"
+  | "done";
+
+/** Flattened session for dashboard rendering. String dates for JSON safety. */
+export interface DashboardSession {
+  id: string;
+  projectId: string;
+  status: SessionStatus;
+  activity: ActivityState | null;
+  branch: string | null;
+  issueId: string | null;
+  summary: string | null;
+  createdAt: string;
+  lastActivityAt: string;
+  pr: DashboardPR | null;
+  metadata: Record<string, string>;
+}
+
+/** Flattened PR for dashboard rendering. */
+export interface DashboardPR {
+  number: number;
+  url: string;
+  title: string;
+  branch: string;
+  baseBranch: string;
+  isDraft: boolean;
+  state: PRState;
+  ciStatus: CIStatus;
+  reviewDecision: ReviewDecision;
+  mergeability: MergeReadiness;
+  previewUrl: string | null;
+}
+
+/** Aggregate stats for the dashboard status line. */
+export interface DashboardStats {
+  totalSessions: number;
+  workingSessions: number;
+  openPRs: number;
+  needsAttention: number;
+}
+
+/** SSE snapshot event from /api/events */
+export interface SSESnapshotEvent {
+  type: "snapshot";
+  sessions: Array<{
+    id: string;
+    status: SessionStatus;
+    activity: ActivityState | null;
+    attentionLevel: AttentionLevel;
+    projectId: string;
+    issueId: string | null;
+    branch: string | null;
+    createdAt: string;
+    lastActivityAt: string;
+    metadata: Record<string, string>;
+    summary?: string | null;
+    pr?: DashboardPR | null;
+  }>;
+}
+
+/** Session statuses that indicate the session is no longer active. */
+export const TERMINAL_STATUSES = new Set([
+  "archived",
+  "done",
+  "killed",
+  "errored",
+  "terminated",
+  "merged",
+  "cleanup",
+]);
+
+/** Determines which attention zone a session belongs to. */
+export function getAttentionLevel(session: DashboardSession): AttentionLevel {
+  // Done: terminal states (matches TERMINAL_STATUSES)
+  if (
+    session.status === "merged" ||
+    session.status === "archived" ||
+    session.status === "killed" ||
+    session.status === "errored" ||
+    session.status === "cleanup" ||
+    session.status === "done" ||
+    session.status === "terminated"
+  ) {
+    return "done";
+  }
+  if (session.pr) {
+    if (session.pr.state === "merged" || session.pr.state === "closed") {
+      return "done";
+    }
+  }
+
+  // Merge: PR is ready -- one click to clear
+  if (session.status === "mergeable" || session.status === "approved") {
+    return "merge";
+  }
+  if (session.pr?.mergeability.mergeable) {
+    return "merge";
+  }
+
+  // Respond: agent is waiting for human input
+  if (
+    session.activity === "waiting_input" ||
+    session.activity === "blocked"
+  ) {
+    return "respond";
+  }
+  if (
+    session.status === "needs_input" ||
+    session.status === "stuck"
+  ) {
+    return "respond";
+  }
+  // Exited agent with non-terminal status = crashed
+  if (session.activity === "exited") {
+    return "respond";
+  }
+
+  // Review: problems that need investigation
+  if (session.status === "ci_failed" || session.status === "changes_requested") {
+    return "review";
+  }
+  if (session.pr) {
+    if (session.pr.ciStatus === "failing") return "review";
+    if (session.pr.reviewDecision === "changes_requested") return "review";
+    if (!session.pr.mergeability.noConflicts) return "review";
+  }
+
+  // Pending: waiting on external (reviewer, CI)
+  if (session.status === "review_pending") {
+    return "pending";
+  }
+  if (session.pr) {
+    if (
+      !session.pr.isDraft &&
+      (session.pr.reviewDecision === "pending" || session.pr.reviewDecision === "none")
+    ) {
+      return "pending";
+    }
+  }
+
+  // Working: agents doing their thing
+  return "working";
+}