bosun 0.42.0 → 0.42.2

package/server/ui-server.mjs

@@ -44,6 +44,7 @@ import {
 } from "../kanban/kanban-adapter.mjs";
 
 import {
+  addActiveSessionListener,
   getActiveThreads,
   launchEphemeralThread,
   launchOrResumeThread,
@@ -132,6 +133,10 @@ import {
   listActiveInstances,
   selectCoordinator,
 } from "../infra/presence.mjs";
+import {
+  normalizeWorktreeRecoveryState,
+  readWorktreeRecoveryState,
+} from "../infra/worktree-recovery-state.mjs";
 import {
   loadWorkspaceRegistry,
   getLocalWorkspace,
@@ -155,10 +160,12 @@ import {
 import {
   getSessionTracker,
   addSessionEventListener,
+  addSessionStateListener,
 } from "../infra/session-tracker.mjs";
 import { ensureTestRuntimeSandbox } from "../infra/test-runtime.mjs";
 import {
   addSessionAccumulationListener,
+  exportRuntimeData,
   getCompletedSessions,
   getRuntimeStats,
   getTaskLifetimeTotals,
@@ -206,6 +213,17 @@ import {
   mergeTaskAttachments,
 } from "../task/task-attachments.mjs";
 import { getVisionSessionState } from "../voice/vision-session-state.mjs";
+import {
+  buildLogStreamPayload,
+  buildMonitorStatsPayload,
+  buildSessionEventPayload,
+  buildSessionsUpdatePayload,
+  buildTasksUpdatePayload,
+  buildWorkflowStatusPayload,
+  createTuiStatsEmitter,
+  persistCompatibleTuiAuthToken,
+  resolveTuiAuthToken,
+} from "../infra/tui-bridge.mjs";
 
 const TASK_STORE_MODULE_PATH = "../task/task-store.mjs";
 const TASK_STORE_START_GUARD_EXPORTS = [
@@ -228,6 +246,10 @@ const TASK_STORE_DAG_EXPORTS = Object.freeze({
 });
 const TASK_STORE_GET_TASK_EXPORTS = ["getTaskById", "getTask"];
 const TASK_STORE_COMMENT_EXPORTS = ["getTaskComments", "listTaskComments"];
+const TASK_STORE_RUN_EXPORTS = {
+  list: ["getTaskRuns", "listTaskRuns"],
+  append: ["appendTaskRun", "addTaskRun"],
+};
 const TASK_STORE_DEPENDENCY_EXPORTS = {
   add: ["addTaskDependency"],
   remove: ["removeTaskDependency"],
@@ -2169,6 +2191,261 @@ function resolvePrimaryWorkspaceId() {
   }
 }
 
+function normalizeDiffTaskRef(value) {
+  return String(value || "").trim();
+}
+
+function collectTaskWorkflowRunEntries(task) {
+  return [
+    ...(Array.isArray(task?.workflowRuns) ? task.workflowRuns : []),
+    ...(Array.isArray(task?.workflowHistory) ? task.workflowHistory : []),
+    ...(Array.isArray(task?.workflows) ? task.workflows : []),
+    ...(Array.isArray(task?.meta?.workflowRuns) ? task.meta.workflowRuns : []),
+  ];
+}
+
+function collectTaskDiffSessionIds(task) {
+  const ids = new Set();
+  const push = (value) => {
+    const normalized = normalizeDiffTaskRef(value);
+    if (normalized) ids.add(normalized);
+  };
+
+  push(task?.sessionId);
+  push(task?.primarySessionId);
+  push(task?.meta?.sessionId);
+  push(task?.meta?.primarySessionId);
+
+  for (const entry of collectTaskWorkflowRunEntries(task)) {
+    push(entry?.sessionId);
+    push(entry?.primarySessionId);
+    push(entry?.threadId);
+    push(entry?.agentSessionId);
+    push(entry?.meta?.sessionId);
+    push(entry?.meta?.threadId);
+  }
+
+  return [...ids];
+}
+
+function collectTaskDiffCommitRefs(task) {
+  const refs = new Set();
+  const push = (value) => {
+    const normalized = normalizeDiffTaskRef(value);
+    if (normalized) refs.add(normalized);
+  };
+
+  push(task?.commitSha);
+  push(task?.sha);
+  push(task?.headSha);
+  push(task?.mergeCommitSha);
+  push(task?.meta?.commitSha);
+  push(task?.meta?.sha);
+  push(task?.meta?.headSha);
+  push(task?.meta?.mergeCommitSha);
+  push(task?.meta?.pr?.headSha);
+  push(task?.meta?.pr?.mergeCommitSha);
+
+  return [...refs];
+}
+
+function pickTaskDiffBranch(task) {
+  return (
+    normalizeDiffTaskRef(task?.branchName) ||
+    normalizeDiffTaskRef(task?.branch) ||
+    normalizeDiffTaskRef(task?.meta?.branchName) ||
+    normalizeDiffTaskRef(task?.meta?.branch) ||
+    normalizeDiffTaskRef(task?.meta?.pr?.headRefName) ||
+    ""
+  );
+}
+
+function pickTaskDiffBaseBranch(task) {
+  return (
+    normalizeDiffTaskRef(task?.baseBranch) ||
+    normalizeDiffTaskRef(task?.base_branch) ||
+    normalizeDiffTaskRef(task?.meta?.baseBranch) ||
+    normalizeDiffTaskRef(task?.meta?.base_branch) ||
+    normalizeDiffTaskRef(task?.meta?.pr?.baseRefName) ||
+    "origin/main"
+  );
+}
+
+function resolveTaskWorkspaceEntry(task, workspaceContext = {}) {
+  const configDir = resolveUiConfigDir();
+  if (!configDir) return null;
+  const listed = listManagedWorkspaces(configDir, { repoRoot });
+  const taskWorkspace = normalizeDiffTaskRef(task?.workspace || task?.meta?.workspace);
+  const taskWorkspacePath = normalizeCandidatePath(taskWorkspace);
+  const workspaceId = normalizeDiffTaskRef(workspaceContext?.workspaceId || workspaceContext?.workspaceFilter);
+
+  return (
+    (taskWorkspace
+      ? listed.find((entry) => {
+          const id = normalizeDiffTaskRef(entry?.id);
+          const entryPath = normalizeCandidatePath(entry?.path);
+          return id === taskWorkspace || (taskWorkspacePath && entryPath && entryPath === taskWorkspacePath);
+        })
+      : null) ||
+    (workspaceId
+      ? listed.find((entry) => normalizeDiffTaskRef(entry?.id) === workspaceId)
+      : null) ||
+    getActiveManagedWorkspace(configDir) ||
+    listed[0] ||
+    null
+  );
+}
+
+function resolveTaskRepositoryDir(task, workspaceContext = {}) {
+  const repositoryName = normalizeDiffTaskRef(task?.repository || task?.meta?.repository);
+  const taskWorkspace = normalizeDiffTaskRef(task?.workspace || task?.meta?.workspace);
+  const taskWorkspacePath = normalizeCandidatePath(taskWorkspace);
+  const workspaceEntry = resolveTaskWorkspaceEntry(task, workspaceContext);
+  const candidates = [];
+
+  const pushCandidate = (candidate) => {
+    const normalized = normalizeCandidatePath(candidate);
+    if (normalized && !candidates.includes(normalized)) candidates.push(normalized);
+  };
+
+  if (taskWorkspacePath && repositoryName) pushCandidate(resolve(taskWorkspacePath, repositoryName));
+  if (taskWorkspacePath) pushCandidate(taskWorkspacePath);
+
+  if (workspaceEntry) {
+    const repos = Array.isArray(workspaceEntry.repos) ? workspaceEntry.repos : [];
+    const matchedRepo = repositoryName
+      ? repos.find((repo) => {
+          const values = [
+            normalizeDiffTaskRef(repo?.name),
+            normalizeDiffTaskRef(repo?.slug),
+            normalizeCandidatePath(repo?.path),
+          ].filter(Boolean);
+          return values.includes(repositoryName) || values.includes(normalizeCandidatePath(repositoryName));
+        })
+      : null;
+    if (matchedRepo?.path) pushCandidate(matchedRepo.path);
+    if (workspaceEntry.path && repositoryName) pushCandidate(resolve(workspaceEntry.path, repositoryName));
+    pushCandidate(pickWorkspaceRepoDir(workspaceEntry));
+    pushCandidate(workspaceEntry.path);
+  }
+
+  if (workspaceContext?.workspaceDir && repositoryName) {
+    pushCandidate(resolve(workspaceContext.workspaceDir, repositoryName));
+  }
+  pushCandidate(workspaceContext?.workspaceDir);
+  pushCandidate(repoRoot);
+
+  for (const candidate of candidates) {
+    if (!candidate || !existsSync(candidate)) continue;
+    if (existsSync(resolve(candidate, ".git"))) return candidate;
+  }
+  return candidates.find((candidate) => candidate && existsSync(candidate)) || "";
+}
+
+function emptyTaskDiffPayload(formatted, source = {}) {
+  return {
+    diff: {
+      files: [],
+      totalFiles: 0,
+      totalAdditions: 0,
+      totalDeletions: 0,
+      formatted,
+    },
+    summary: formatted,
+    commits: [],
+    source,
+  };
+}
+
+async function buildTaskDiffPayload(task, workspaceContext = {}) {
+  if (!task) {
+    return emptyTaskDiffPayload("(task not found)", { kind: "task", detail: "Task could not be loaded." });
+  }
+
+  const baseBranch = pickTaskDiffBaseBranch(task);
+
+  for (const sessionId of collectTaskDiffSessionIds(task)) {
+    try {
+      const session = tracker.getSession(sessionId);
+      if (!session) continue;
+      const worktreePath = await resolveSessionWorktreePath(session);
+      if (!worktreePath || !existsSync(worktreePath)) continue;
+      const diff = collectDiffStats(worktreePath, {
+        baseBranch,
+        includePatch: true,
+      });
+      if (diff.totalFiles > 0) {
+        return {
+          diff,
+          summary: diff.formatted,
+          commits: getRecentCommits(worktreePath),
+          source: {
+            kind: "session",
+            label: diff.sourceRange || "session worktree",
+            detail: worktreePath,
+          },
+        };
+      }
+    } catch {
+      // Fall through to branch or commit resolution.
+    }
+  }
+
+  const repoPath = resolveTaskRepositoryDir(task, workspaceContext);
+  if (!repoPath || !existsSync(repoPath)) {
+    return emptyTaskDiffPayload("(no repository for task diff)", {
+      kind: "task",
+      detail: "No repository or preserved worktree is available for this task.",
+    });
+  }
+
+  const attempts = [];
+  const branch = pickTaskDiffBranch(task);
+  if (branch) {
+    attempts.push({
+      kind: "branch",
+      label: `${baseBranch}...${branch}`,
+      options: { baseBranch, targetRef: branch, includePatch: true },
+    });
+  }
+  for (const commitRef of collectTaskDiffCommitRefs(task)) {
+    attempts.push({
+      kind: "commit",
+      label: commitRef,
+      options: { range: `${commitRef}^..${commitRef}`, includePatch: true },
+    });
+  }
+  if (!attempts.length) {
+    attempts.push({
+      kind: "task",
+      label: `${baseBranch}...HEAD`,
+      options: { baseBranch, includePatch: true },
+    });
+  }
+
+  for (const attempt of attempts) {
+    const diff = collectDiffStats(repoPath, attempt.options);
+    if (diff.totalFiles > 0) {
+      return {
+        diff,
+        summary: diff.formatted,
+        commits: getRecentCommits(repoPath),
+        source: {
+          kind: attempt.kind,
+          label: diff.sourceRange || attempt.label,
+          detail: repoPath,
+        },
+      };
+    }
+  }
+
+  return emptyTaskDiffPayload("(no diff available)", {
+    kind: branch ? "branch" : "task",
+    label: branch ? `${baseBranch}...${branch}` : "",
+    detail: repoPath,
+  });
+}
+
 function taskMatchesWorkspaceContext(task, workspaceContext) {
   const workspaceFilter = String(
     workspaceContext?.workspaceFilter || workspaceContext?.workspaceId || "",
@@ -4623,14 +4900,22 @@ let _browserOpened = false;
 const AUTO_OPEN_MARKER_FILE = "ui-auto-open.json";
 const UI_INSTANCE_LOCK_FILE = "ui-server.instance.lock.json";
 const UI_SESSION_TOKEN_FILE = "ui-session-token.json";
+const TUI_SESSION_TOKEN_FILE = "ui-token";
 const UI_LAST_PORT_FILE = "ui-last-port.json";
 const DEFAULT_AUTO_OPEN_COOLDOWN_MS = 12 * 60 * 60 * 1000; // 12h
 const DEFAULT_SESSION_TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const wsClients = new Set();
 let sessionListenerAttached = false;
+let sessionStateListenerAttached = false;
+let activeSessionListenerAttached = false;
 let sessionAccumulatorListenerAttached = false;
+let removeSessionEventListener = null;
+let removeSessionStateListener = null;
+let removeActiveSessionListener = null;
+let removeSessionAccumulatorListener = null;
 /** @type {ReturnType<typeof setInterval>|null} */
 let wsHeartbeatTimer = null;
+let tuiStatsEmitter = null;
 const WORKFLOW_WS_BATCH_MS = 80;
 const workflowWsBatchByKey = new Map();
 const workflowEngineListenerCleanup = new WeakMap();
@@ -4688,6 +4973,35 @@ async function resolveVoiceRelay() {
 let _fallbackExecPrimaryPrompt = null;
 /** Track in-flight chat turns so /api/sessions/:id/stop can abort them. */
 const sessionRunAbortControllers = new Map();
+let _activeSessions = [];
+
+function getLiveSessionSnapshot({ includeHidden = false } = {}) {
+  const tracker = getSessionTracker();
+  let sessions = tracker.listAllSessions();
+  if (!includeHidden) {
+    sessions = sessions.filter((session) => {
+      const detailed = tracker.getSessionById(session.id) || session;
+      return !shouldHideSessionFromDefaultList(detailed);
+    });
+  }
+  return sessions;
+}
+
+function broadcastSessionsSnapshot(sessions = getLiveSessionSnapshot()) {
+  const normalized = Array.isArray(sessions) ? sessions : [];
+  broadcastUiEvent(["sessions", "tui"], "sessions:update", {
+    sessions: normalized,
+  });
+}
+
+function updateActiveSessions(sessions) {
+  _activeSessions = Array.isArray(sessions) ? sessions : [];
+  broadcastSessionsSnapshot(_activeSessions);
+  for (const session of _activeSessions) {
+    broadcastUiEvent(["sessions", "tui"], "session:update", session);
+  }
+}
+
 async function resolveExecPrimaryPrompt() {
   if (typeof uiDeps.execPrimaryPrompt === "function") return uiDeps.execPrimaryPrompt;
   if (_fallbackExecPrimaryPrompt) return _fallbackExecPrimaryPrompt;
@@ -4989,6 +5303,17 @@ function isValidSessionToken(token) {
 }
 
 function readPersistedSessionToken() {
+  const envToken = resolveTuiAuthToken({ env: process.env, configDir: resolveUiConfigDir() });
+  if (isValidSessionToken(envToken)) return envToken;
+  try {
+    const plainTokenPath = resolveUiCachePath(TUI_SESSION_TOKEN_FILE);
+    if (existsSync(plainTokenPath)) {
+      const plainToken = String(readFileSync(plainTokenPath, "utf8") || "").trim();
+      if (isValidSessionToken(plainToken)) return plainToken;
+    }
+  } catch {
+    // best effort
+  }
   try {
     const tokenPath = resolveUiCachePath(UI_SESSION_TOKEN_FILE);
     if (!existsSync(tokenPath)) return "";
@@ -5006,6 +5331,7 @@ function readPersistedSessionToken() {
 
 function persistSessionToken(token) {
   if (!isValidSessionToken(token)) return;
+  process.env.BOSUN_UI_TOKEN = token;
   try {
     const tokenPath = resolveUiCachePath(UI_SESSION_TOKEN_FILE);
     writeFileSync(
@@ -5021,6 +5347,7 @@ function persistSessionToken(token) {
       ),
       "utf8",
     );
+    persistCompatibleTuiAuthToken(token, { configDir: resolveUiConfigDir() });
   } catch {
     // best effort
   }
@@ -5040,6 +5367,7 @@ function ensureSessionToken() {
   const persisted = readPersistedSessionToken();
   if (persisted) {
     sessionToken = persisted;
+    persistSessionToken(sessionToken);
     return sessionToken;
   }
   sessionToken = randomBytes(32).toString("hex");
@@ -9095,6 +9423,87 @@ function sendWsMessage(socket, payload) {
   }
 }
 
+function broadcastCanonicalEvent(channels, type, payload = {}) {
+  const required = new Set(Array.isArray(channels) ? channels : [channels]);
+  const message = {
+    type,
+    channels: Array.from(required),
+    payload,
+    ts: Date.now(),
+  };
+  for (const socket of wsClients) {
+    const subscribed = socket.__channels || new Set(["*"]);
+    const shouldSend = subscribed.has("*") || Array.from(required).some((channel) => subscribed.has(channel));
+    if (shouldSend) sendWsMessage(socket, message);
+  }
+}
+
+function getCurrentSessionSnapshot() {
+  try {
+    const tracker = getSessionTracker();
+    return buildSessionsUpdatePayload(tracker?.listAllSessions?.() || []);
+  } catch {
+    return [];
+  }
+}
+
+function broadcastTuiSessionsSnapshot(reason = "updated", detail = {}) {
+  broadcastCanonicalEvent(["sessions", "tui"], "sessions:update", getCurrentSessionSnapshot());
+  const sessionEvent = buildSessionEventPayload({
+    sessionId: detail?.sessionId || detail?.session?.id || detail?.threadId || detail?.taskKey || "",
+    taskId: detail?.taskId || detail?.session?.taskId || detail?.taskKey || "",
+    session: detail?.session || detail,
+    event: {
+      kind: "state",
+      reason,
+      ...(detail && typeof detail === "object" ? detail : {}),
+    },
+  });
+  if (sessionEvent.sessionId && sessionEvent.taskId) {
+    broadcastCanonicalEvent(["sessions", "tui"], "session:event", sessionEvent);
+  }
+}
+
+function buildCurrentTuiMonitorStats() {
+  const executor = uiDeps.getInternalExecutor?.() || null;
+  const injectedStats = uiDeps.getTuiMonitorStats?.() || {};
+  const status = executor?.getStatus?.() || {};
+  const slots = Array.isArray(status?.slots) ? status.slots : [];
+  const runtimeStats = getRuntimeStats() || {};
+  const runtimeSessions = Array.isArray(runtimeStats?.sessions) ? runtimeStats.sessions : [];
+
+  const pickNumericStat = (...candidates) => {
+    for (const candidate of candidates) {
+      if (candidate == null) continue;
+      const numeric = Number(candidate);
+      if (Number.isFinite(numeric)) {
+        return numeric;
+      }
+    }
+    return 0;
+  };
+  const tokensIn = pickNumericStat(injectedStats?.tokensIn, runtimeStats?.totalInputTokens);
+  const tokensOut = pickNumericStat(injectedStats?.tokensOut, runtimeStats?.totalOutputTokens);
+
+  return buildMonitorStatsPayload({
+    agentPool: {
+      activeAgents: pickNumericStat(status?.activeSlots, slots.length, injectedStats?.activeAgents),
+      maxAgents: pickNumericStat(status?.maxParallel, injectedStats?.maxAgents),
+      tokensIn: pickNumericStat(injectedStats?.tokensIn, tokensIn),
+      tokensOut: pickNumericStat(injectedStats?.tokensOut, tokensOut),
+      throughputTps: injectedStats?.throughputTps,
+      rateLimits: injectedStats?.rateLimits || {},
+    },
+    runtimeStats: {
+      ...runtimeStats,
+      sessions: runtimeSessions,
+      totalInputTokens: tokensIn,
+      totalOutputTokens: tokensOut,
+    },
+    uptimeMs: runtimeStats?.startedAt ? Date.now() - Number(runtimeStats.startedAt) : process.uptime() * 1000,
+  });
+}
+
 function normalizeWorkflowNodeStatus(status) {
   const normalized = String(status || "").trim().toLowerCase();
   if (normalized === "completed" || normalized === "success") return "success";
@@ -9138,6 +9547,106 @@ function summarizeOutputLines(value, maxLines = 3, maxChars = 140) {
   return lines;
 }
 
+function summarizeTrajectoryText(value, maxLength = 160) {
+  const text = String(value ?? "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join(" ")
+    .replace(/\s{2,}/g, " ")
+    .trim();
+  if (!text) return null;
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+}
+
+function classifyTrajectorySessionEvent(event = {}) {
+  const payload = event && typeof event === "object" ? event : {};
+  const role = String(payload?.role || payload?.message?.role || "").trim().toLowerCase();
+  const type = String(payload?.type || payload?.message?.type || payload?.event?.kind || "").trim().toLowerCase();
+  if (role === "user") return "user";
+  if (role === "assistant") return "assistant";
+  if (type.includes("tool") && (type.includes("result") || type.includes("output"))) return "tool_result";
+  if (type.includes("tool")) return "tool_call";
+  if (type.includes("reason") || type.includes("thinking")) return "reasoning";
+  if (type === "error") return "status";
+  return "event";
+}
+
+function buildTrajectoryStepFromSessionEvent(event = {}) {
+  const normalizedType = classifyTrajectorySessionEvent(event);
+  const message = event?.message && typeof event.message === "object" ? event.message : event;
+  const content = message?.content ?? event?.content ?? null;
+  const summary = summarizeTrajectoryText(
+    message?.summary || event?.summary || content || event?.label || event?.reason || event?.type || "Run event recorded.",
+  ) || "Run event recorded.";
+  return {
+    id: String(event?.id || message?.id || `step-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`),
+    at: String(event?.timestamp || message?.timestamp || event?.at || new Date().toISOString()),
+    type: normalizedType,
+    summary,
+    payload: {
+      role: message?.role || event?.role || null,
+      type: message?.type || event?.type || null,
+      content: typeof content === "string" ? content : null,
+      reason: event?.reason || null,
+    },
+    event: event && typeof event === "object" ? { ...event } : null,
+  };
+}
+
+function buildTaskRunSummary(steps = [], fallback = "Run recorded.") {
+  const ordered = Array.isArray(steps) ? steps : [];
+  for (let index = ordered.length - 1; index >= 0; index -= 1) {
+    const summary = summarizeTrajectoryText(ordered[index]?.summary || "");
+    if (summary) return summary;
+  }
+  return fallback;
+}
+
+async function buildReplayableTaskRuns(task, tracker = null, limit = 5) {
+  const sessionIds = collectTaskDiffSessionIds(task);
+  const { value: storedRunsRaw } = await callTaskStoreFunction(TASK_STORE_RUN_EXPORTS.list, [task?.id]);
+  const storedRuns = storedRunsRaw;
+  const runs = Array.isArray(storedRuns) ? storedRuns.map((run) => ({
+    ...run,
+    summary: run.summary || buildTaskRunSummary(run.steps, run.status === "failed" ? "Run failed." : "Run completed."),
+  })) : [];
+  const seenRunIds = new Set(runs.map((entry) => String(entry?.runId || "")).filter(Boolean));
+  for (const sessionId of sessionIds) {
+    const session = tracker?.getSession?.(sessionId);
+    if (!session) continue;
+    const events = Array.isArray(session?.events) ? session.events : [];
+    const steps = events.map((event) => buildTrajectoryStepFromSessionEvent(event)).filter(Boolean);
+    if (steps.length === 0) continue;
+    const runId = String(sessionId || session?.id || "").trim();
+    if (!runId || seenRunIds.has(runId)) continue;
+    seenRunIds.add(runId);
+    runs.push({
+      runId,
+      startedAt: String(session?.createdAt || steps[0]?.at || new Date().toISOString()),
+      endedAt: session?.status === "active" ? null : String(session?.updatedAt || steps.at(-1)?.at || new Date().toISOString()),
+      status: String(session?.status || "completed"),
+      taskKey: String(task?.id || session?.taskId || "").trim() || null,
+      sdk: String(session?.executor || session?.sdk || session?.metadata?.resolvedSdk || "").trim() || null,
+      threadId: String(session?.threadId || session?.metadata?.threadId || "").trim() || null,
+      resumeThreadId: String(session?.metadata?.resumeThreadId || session?.threadId || "").trim() || null,
+      replayable: true,
+      outcome: session?.status === "failed" ? "failed" : "completed",
+      summary: buildTaskRunSummary(steps, session?.status === "failed" ? "Run failed." : "Run completed."),
+      steps,
+      meta: {
+        sessionId: runId,
+        source: "session-tracker",
+      },
+    });
+  }
+  runs.sort((left, right) => Date.parse(String(right?.startedAt || 0)) - Date.parse(String(left?.startedAt || 0)));
+  return runs.slice(0, Math.max(1, Number(limit) || 5));
+}
+
 function buildWorkflowNodeOutputPreview(nodeType, output = null) {
   if (output == null) return { lines: [] };
   const type = String(nodeType || "").trim().toLowerCase();
@@ -9278,6 +9787,13 @@ function attachWorkflowEngineLiveBridge(engine) {
   };
 
   listen("run:start", (payload) => {
+    broadcastCanonicalEvent(["workflows", "tui"], "workflow:status", buildWorkflowStatusPayload({
+      ...payload,
+      workflowName: payload.name || payload.workflowName || null,
+      eventType: "run:start",
+      status: "running",
+      timestamp: Date.now(),
+    }));
     queueWorkflowWsEvent({
       kind: "run",
       workflowId: payload.workflowId,
@@ -9289,6 +9805,14 @@ function attachWorkflowEngineLiveBridge(engine) {
     });
   });
   listen("run:end", (payload) => {
+    broadcastCanonicalEvent(["workflows", "tui"], "workflow:status", buildWorkflowStatusPayload({
+      ...payload,
+      workflowName: payload.workflowName || payload.name || null,
+      eventType: "run:end",
+      durationMs: Number(payload.duration) || null,
+      status: String(payload.status || "").trim().toLowerCase() || "completed",
+      timestamp: Date.now(),
+    }));
     queueWorkflowWsEvent({
       kind: "run",
       workflowId: payload.workflowId,
@@ -9301,6 +9825,13 @@ function attachWorkflowEngineLiveBridge(engine) {
     });
   });
   listen("run:error", (payload) => {
+    broadcastCanonicalEvent(["workflows", "tui"], "workflow:status", buildWorkflowStatusPayload({
+      ...payload,
+      workflowName: payload.workflowName || payload.name || null,
+      eventType: "run:error",
+      status: "failed",
+      timestamp: Date.now(),
+    }));
     queueWorkflowWsEvent({
       kind: "run",
       workflowId: payload.workflowId,
@@ -9338,6 +9869,13 @@ function attachWorkflowEngineLiveBridge(engine) {
     });
   });
   listen("node:complete", (payload) => {
+    broadcastCanonicalEvent(["workflows", "tui"], "workflow:status", buildWorkflowStatusPayload({
+      ...payload,
+      workflowName: payload.workflowName || null,
+      eventType: "node:complete",
+      status: "success",
+      timestamp: Date.now(),
+    }));
     const preview = buildWorkflowNodeOutputPreview(payload.nodeType, payload.output);
     queueWorkflowWsEvent({
       kind: "node",
@@ -9408,21 +9946,13 @@ function attachWorkflowEngineLiveBridge(engine) {
 }
 
 function broadcastUiEvent(channels, type, payload = {}) {
-  const required = new Set(Array.isArray(channels) ? channels : [channels]);
-  const message = {
-    type,
-    channels: Array.from(required),
-    payload,
-    ts: Date.now(),
-  };
-  for (const socket of wsClients) {
-    const subscribed = socket.__channels || new Set(["*"]);
-    const shouldSend =
-      subscribed.has("*") ||
-      Array.from(required).some((channel) => subscribed.has(channel));
-    if (shouldSend) {
-      sendWsMessage(socket, message);
-    }
+  const required = Array.isArray(channels) ? channels : [channels];
+  broadcastCanonicalEvent(required, type, payload);
+  if (required.includes("sessions") && type !== "sessions:update" && type !== "session:event") {
+    broadcastTuiSessionsSnapshot(type, payload);
+  }
+  if (required.includes("tasks") && type !== "tasks:update") {
+    broadcastCanonicalEvent(["tasks", "tui"], "tasks:update", buildTasksUpdatePayload(payload, { sourceEvent: type }));
   }
 }
 
@@ -9443,6 +9973,20 @@ function broadcastSessionMessage(payload) {
       sendWsMessage(socket, message);
     }
   }
+
+  const sessionEvent = buildSessionEventPayload({
+    sessionId: payload?.sessionId || payload?.session?.id || payload?.taskId || "",
+    taskId: payload?.taskId || payload?.session?.taskId || payload?.sessionId || "",
+    session: payload?.session || {},
+    event: {
+      kind: "message",
+      message: payload?.message ?? null,
+    },
+  });
+  if (sessionEvent.sessionId && sessionEvent.taskId) {
+    broadcastCanonicalEvent(["sessions", "tui"], "session:event", sessionEvent);
+  }
+  broadcastCanonicalEvent(["sessions", "tui"], "sessions:update", getCurrentSessionSnapshot());
 }
 
 async function collectUiStats() {
@@ -9698,7 +10242,6 @@ function startLogStream(socket, logType, query) {
         // File was truncated/rotated — reset
         streamState.offset = 0;
       }
-
       if (size <= streamState.offset) return;
 
       // Read only new bytes
@@ -10490,7 +11033,13 @@ async function handleDeviceFlowPoll(req, res) {
 async function readStatusSnapshot() {
   try {
     const raw = await readFile(statusPath, "utf8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      parsed.worktreeRecovery = normalizeWorktreeRecoveryState(
+        parsed.worktreeRecovery || parsed.worktree_recovery || null,
+      );
+    }
+    return parsed;
   } catch {
     return null;
   }
@@ -10918,9 +11467,9 @@ async function tailFile(filePath, lineCount, maxBytes = 1_000_000) {
   };
 }
 
-async function readJsonlTail(filePath, maxLines = 2000) {
+async function readJsonlTail(filePath, maxLines = 2000, maxBytes = 1_000_000) {
   if (!existsSync(filePath)) return [];
-  const tail = await tailFile(filePath, maxLines);
+  const tail = await tailFile(filePath, maxLines, maxBytes);
   return (tail.lines || [])
     .map((line) => {
       try {
@@ -10994,7 +11543,7 @@ async function readCompletedSessionEntries(maxLines = 100_000) {
       }
     } catch { /* stat failed, skip */ }
   }
-  const entries = await readJsonlTail(sessionLogPath, maxLines);
+  const entries = await readJsonlTail(sessionLogPath, maxLines, 50_000_000);
   return {
     sessionLogPath,
     entries: entries.filter((entry) => String(entry?.type || "completed_session") === "completed_session"),
@@ -11138,7 +11687,7 @@ async function buildUsageAnalytics(days) {
   const streamPath = resolve(logDir, "agent-work-stream.jsonl");
   const [{ entries: completedSessions }, events] = await Promise.all([
     readCompletedSessionEntries(100_000),
-    readJsonlTail(streamPath, 100_000),
+    readJsonlTail(streamPath, 100_000, 50_000_000),
   ]);
 
   const cutoff = days ? Date.now() - days * 24 * 60 * 60 * 1000 : 0;
@@ -11306,6 +11855,162 @@ function resolveAgentWorkLogDir() {
   return candidates[0];
 }
 
+function clampRunSummaryText(value, maxLength = 220) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+
+function summarizeTrajectoryEvent(event = {}) {
+  const type = String(event?.event_type || event?.type || "event").trim() || "event";
+  const data = event?.data && typeof event.data === "object" ? event.data : {};
+  if (type === "session_start") {
+    return clampRunSummaryText(`Started ${String(event.executor || event.model || "agent").trim() || "agent"} run for ${String(event.task_title || event.taskId || "task").trim() || "task"}`);
+  }
+  if (type === "session_end") {
+    const status = String(data?.completion_status || event?.status || "completed").trim() || "completed";
+    return clampRunSummaryText(`Finished run with status ${status}`);
+  }
+  if (type === "tool_call") {
+    const toolName = String(data?.tool_name || event?.tool_name || "tool").trim() || "tool";
+    return clampRunSummaryText(`Called ${toolName}`);
+  }
+  if (type === "tool_result") {
+    const toolName = String(data?.tool_name || event?.tool_name || "tool").trim() || "tool";
+    const status = String(data?.status || event?.status || "completed").trim() || "completed";
+    return clampRunSummaryText(`${toolName} returned ${status}`);
+  }
+  if (type === "error") {
+    const message = String(data?.error_message || event?.error_message || event?.message || "error").trim() || "error";
+    return clampRunSummaryText(`Error: ${message}`);
+  }
+  if (type === "usage") {
+    const totalTokens = numberOrZero(data?.total_tokens || data?.tokens || event?.total_tokens);
+    if (totalTokens > 0) return clampRunSummaryText(`Used ${totalTokens} tokens`);
+  }
+  if (type === "agent_output") {
+    const output = String(data?.output || event?.output || "").trim();
+    if (output) return clampRunSummaryText(output);
+  }
+  return clampRunSummaryText(type.replace(/_/g, " "));
+}
+
+function toTrajectoryReplayEvent(event = {}, index = 0) {
+  const timestamp = event?.timestamp || event?.recordedAt || null;
+  const eventType = String(event?.event_type || event?.type || "event").trim() || "event";
+  const data = event?.data && typeof event.data === "object" ? event.data : {};
+  return {
+    index,
+    timestamp,
+    type: eventType,
+    summary: summarizeTrajectoryEvent(event),
+    attemptId: String(event?.attempt_id || event?.attemptId || "").trim() || null,
+    taskId: String(event?.taskId || "").trim() || null,
+    taskTitle: String(event?.task_title || event?.taskTitle || "").trim() || null,
+    executor: String(event?.executor || event?.model || "").trim() || null,
+    data: makeJsonSafe(data, { maxDepth: 4 }),
+  };
+}
+
+function buildReplayOverview(events = []) {
+  const totals = {
+    events: events.length,
+    toolCalls: 0,
+    toolResults: 0,
+    outputs: 0,
+    errors: 0,
+    usageEvents: 0,
+  };
+  const shortSteps = [];
+  for (const event of events) {
+    if (event.type === "tool_call") totals.toolCalls += 1;
+    if (event.type === "tool_result") totals.toolResults += 1;
+    if (event.type === "agent_output") totals.outputs += 1;
+    if (event.type === "error") totals.errors += 1;
+    if (event.type === "usage") totals.usageEvents += 1;
+    if (shortSteps.length >= 12) continue;
+    if (["session_start", "tool_call", "tool_result", "error", "session_end"].includes(event.type)) {
+      shortSteps.push(event.summary);
+      continue;
+    }
+    if (event.type === "agent_output" && shortSteps.length < 6) shortSteps.push(event.summary);
+  }
+  return { totals, shortSteps };
+}
+
+async function listReplayableAgentRuns(options = {}) {
+  const logDir = resolveAgentWorkLogDir();
+  const sessionsDir = resolve(logDir, "agent-sessions");
+  const limit = Math.max(1, Math.min(100, Number(options.limit) || 25));
+  const taskIdFilter = String(options.taskId || "").trim();
+  const files = await readdir(sessionsDir).catch(() => []);
+  const runs = [];
+
+  for (const name of files) {
+    if (!name.endsWith(".jsonl")) continue;
+    const attemptId = name.replace(/\.jsonl$/i, "");
+    const filePath = resolve(sessionsDir, name);
+    const entries = await readJsonlTail(filePath, 5000, 10000000).catch(() => []);
+    if (!entries.length) continue;
+    const replayEvents = entries.map((entry, index) => toTrajectoryReplayEvent(entry, index));
+    const first = replayEvents[0] || null;
+    const last = replayEvents[replayEvents.length - 1] || null;
+    const taskId = String(first?.taskId || last?.taskId || "").trim() || null;
+    if (taskIdFilter && taskId !== taskIdFilter) continue;
+    const startedAt = first?.timestamp || null;
+    const endedAt = last?.type === "session_end" ? last.timestamp : null;
+    const overview = buildReplayOverview(replayEvents);
+    runs.push({
+      attemptId,
+      taskId,
+      taskTitle: first?.taskTitle || last?.taskTitle || null,
+      executor: first?.executor || last?.executor || null,
+      startedAt,
+      endedAt,
+      status: last?.type === "session_end"
+        ? String(last?.data?.completion_status || "completed")
+        : "in_progress",
+      eventCount: replayEvents.length,
+      shortSteps: overview.shortSteps,
+      totals: overview.totals,
+    });
+  }
+
+  runs.sort((a, b) => {
+    const aTs = Date.parse(String(a.endedAt || a.startedAt || 0)) || 0;
+    const bTs = Date.parse(String(b.endedAt || b.startedAt || 0)) || 0;
+    return bTs - aTs;
+  });
+  return runs.slice(0, limit);
+}
+
+async function readReplayableAgentRun(attemptId) {
+  const normalizedAttemptId = String(attemptId || "").trim();
+  if (!normalizedAttemptId) return null;
+  const filePath = resolve(resolveAgentWorkLogDir(), "agent-sessions", `${normalizedAttemptId}.jsonl`);
+  if (!existsSync(filePath)) return null;
+  const entries = await readJsonlTail(filePath, 20000, 25000000).catch(() => []);
+  if (!entries.length) return null;
+  const events = entries.map((entry, index) => toTrajectoryReplayEvent(entry, index));
+  const first = events[0] || null;
+  const last = events[events.length - 1] || null;
+  const overview = buildReplayOverview(events);
+  return {
+    attemptId: normalizedAttemptId,
+    taskId: first?.taskId || last?.taskId || null,
+    taskTitle: first?.taskTitle || last?.taskTitle || null,
+    executor: first?.executor || last?.executor || null,
+    startedAt: first?.timestamp || null,
+    endedAt: last?.type === "session_end" ? last.timestamp : null,
+    status: last?.type === "session_end"
+      ? String(last?.data?.completion_status || "completed")
+      : "in_progress",
+    shortSteps: overview.shortSteps,
+    totals: overview.totals,
+    events,
+  };
+}
 async function listAgentLogFiles(query = "", limit = 60) {
   const entries = [];
   const agentLogsDir = await resolveAgentLogsDir();
@@ -12166,6 +12871,25 @@ async function handleApi(req, res, url) {
     return;
   }
 
+  if (path === "/api/tasks/diff") {
+    try {
+      const taskId =
+        url.searchParams.get("taskId") || url.searchParams.get("id") || "";
+      if (!taskId) {
+        jsonResponse(res, 400, { ok: false, error: "taskId required" });
+        return;
+      }
+      const workspaceContext = resolveWorkspaceContextFromRequest(url, { allowAll: false });
+      const adapter = getKanbanAdapter();
+      const task = await adapter.getTask(taskId);
+      const payload = await buildTaskDiffPayload(task, workspaceContext);
+      jsonResponse(res, 200, { ok: true, ...payload });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
   if (path === "/api/tasks/detail") {
     try {
       const taskId =
@@ -12215,6 +12939,15 @@ async function handleApi(req, res, url) {
           workspaceDir: workspaceContext?.workspaceDir || repoRoot,
         });
         const diagnostics = buildTaskDiagnostics(detailTask, supervisorDiagnostics);
+        const replayRuns = await buildReplayableTaskRuns(detailTask, getSessionTracker(), 8);
+        if (replayRuns.length > 0) {
+          detailTask.runs = replayRuns;
+          detailTask.meta = {
+            ...(detailTask.meta || {}),
+            latestRunSummary: replayRuns[0]?.summary || null,
+            replayRunCount: replayRuns.length,
+          };
+        }
 
         detailTask.meta = {
           ...(detailTask.meta || {}),
@@ -15266,7 +15999,15 @@ async function handleApi(req, res, url) {
     try {
       const worktrees = listActiveWorktrees(repoRoot);
       const stats = await getWorktreeStats(repoRoot);
-      jsonResponse(res, 200, { ok: true, data: worktrees, stats });
+      const recovery = await readWorktreeRecoveryState(repoRoot);
+      jsonResponse(res, 200, {
+        ok: true,
+        data: worktrees,
+        stats: {
+          ...stats,
+          recovery,
+        },
+      });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -15497,25 +16238,42 @@ async function handleApi(req, res, url) {
       const days = Number(url.searchParams.get("days") || "7");
       const logDir = resolveAgentWorkLogDir();
       const metricsPath = resolve(logDir, "agent-metrics.jsonl");
-      const metrics = await readJsonlTail(metricsPath, 3000);
+      const metrics = await readJsonlTail(metricsPath, 100_000, 50_000_000);
       const summary = summarizeTelemetry(metrics, days) || {};
-      const runtimeStats = getRuntimeStats();
-      const completedSessions = getCompletedSessions(10_000);
-      const lifetimeTotals = completedSessions.reduce(
+
+      // Read lifetime totals from the full JSONL log (not the capped in-memory state)
+      // so the count is accurate even when sessions exceed the in-memory cap.
+      const { entries: allSessions } = await readCompletedSessionEntries(200_000);
+      const lifetimeTotals = allSessions.reduce(
         (acc, session) => {
           acc.attemptsCount += 1;
           acc.tokenCount += Number(session?.tokenCount || 0);
           acc.inputTokens += Number(session?.inputTokens || 0);
           acc.outputTokens += Number(session?.outputTokens || 0);
+          acc.durationMs += Math.max(0, Number(session?.durationMs || 0));
           return acc;
         },
-        { attemptsCount: 0, tokenCount: 0, inputTokens: 0, outputTokens: 0 },
+        { attemptsCount: 0, tokenCount: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 },
       );
-      summary.runtimeMs = Number(runtimeStats?.runtimeMs || 0);
-      summary.lifetimeTotals = {
-        ...lifetimeTotals,
-        durationMs: summary.runtimeMs,
-      };
+
+      // Supplement token counts from agent-metrics.jsonl which has actual LLM usage data
+      // (prompt_tokens, completion_tokens, total_tokens) that the session log may lack.
+      if (lifetimeTotals.tokenCount <= 0 && metrics.length > 0) {
+        let metricsTokens = 0;
+        let metricsInputTokens = 0;
+        let metricsOutputTokens = 0;
+        for (const m of metrics) {
+          const met = m?.metrics || m;
+          metricsTokens += Number(met?.total_tokens || 0);
+          metricsInputTokens += Number(met?.prompt_tokens || 0);
+          metricsOutputTokens += Number(met?.completion_tokens || 0);
+        }
+        lifetimeTotals.tokenCount = metricsTokens;
+        lifetimeTotals.inputTokens = metricsInputTokens;
+        lifetimeTotals.outputTokens = metricsOutputTokens;
+      }
+
+      summary.lifetimeTotals = lifetimeTotals;
       jsonResponse(res, 200, { ok: true, data: summary });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
@@ -15807,7 +16565,33 @@ async function handleApi(req, res, url) {
     return;
   }
 
-  if (path === "/api/agent-logs/context") {
+    if (path === "/api/agent-runs") {
+    try {
+      const limit = Number(url.searchParams.get("limit") || "25");
+      const taskId = String(url.searchParams.get("taskId") || "").trim();
+      const data = await listReplayableAgentRuns({ limit, taskId });
+      jsonResponse(res, 200, { ok: true, data });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+
+  if (path.startsWith("/api/agent-runs/")) {
+    try {
+      const attemptId = decodeURIComponent(path.slice("/api/agent-runs/".length));
+      const data = await readReplayableAgentRun(attemptId);
+      if (!data) {
+        jsonResponse(res, 404, { ok: false, error: "run not found" });
+        return;
+      }
+      jsonResponse(res, 200, { ok: true, data });
+    } catch (err) {
+      jsonResponse(res, 500, { ok: false, error: err.message });
+    }
+    return;
+  }
+if (path === "/api/agent-logs/context") {
     try {
       const query = url.searchParams.get("query") || "";
       if (!query) {
@@ -15906,6 +16690,7 @@ async function handleApi(req, res, url) {
     try {
       const executor = uiDeps.getInternalExecutor?.();
       const status = executor?.getStatus?.() || {};
+      const worktreeRecovery = await readWorktreeRecoveryState(repoRoot);
       const data = {
         executor: {
           mode: uiDeps.getExecutorMode?.() || "internal",
@@ -15913,6 +16698,7 @@ async function handleApi(req, res, url) {
           activeSlots: status.activeSlots || 0,
           paused: executor?.isPaused?.() || false,
         },
+        worktreeRecovery,
         system: {
           uptime: process.uptime(),
           memoryMB: Math.round(process.memoryUsage.rss() / 1024 / 1024),
@@ -18833,7 +19619,23 @@ async function handleApi(req, res, url) {
         const detailed = tracker.getSessionById(session.id) || session;
         return sessionMatchesWorkspaceContext(detailed, workspaceContext);
       });
-      jsonResponse(res, 200, { ok: true, sessions });
+      jsonResponse(res, 200, {
+        ok: true,
+        sessions,
+        loadMeta: {
+          stale: false,
+          lastSuccessAt: new Date().toISOString(),
+          lastFailureAt: null,
+          staleReason: null,
+          staleReasonCode: null,
+          staleReasonLabel: null,
+          staleReasonMeta: null,
+          retryAttempt: 0,
+          retryDelayMs: 0,
+          nextRetryAt: null,
+          retriesExhausted: false,
+        },
+      });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -18869,6 +19671,7 @@ async function handleApi(req, res, url) {
       });
       jsonResponse(res, 200, { ok: true, session: { id: session.id, type: session.type, status: session.status, metadata: session.metadata } });
       broadcastUiEvent(["sessions"], "invalidate", { reason: "session-created", sessionId: id });
+      broadcastSessionsSnapshot();
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -19019,6 +19822,7 @@ async function handleApi(req, res, url) {
           reason: wasRunning ? "session-stop-requested" : "session-stop-noop",
           sessionId,
         });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19071,6 +19875,7 @@ async function handleApi(req, res, url) {
           // Respond immediately so the UI doesn't block on agent execution
           jsonResponse(res, 200, { ok: true, messageId });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
+          broadcastSessionsSnapshot();
 
           // Build an onEvent callback so intermediate SDK events (thinking,
           // tool calls, code edits, etc.) are streamed to the UI in real-time
@@ -19122,6 +19927,7 @@ async function handleApi(req, res, url) {
             // sessions from staying "active" forever and causing session bloat.
             tracker.updateSessionStatus(sessionId, "completed");
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-response", sessionId });
+            broadcastSessionsSnapshot();
           }).catch((execErr) => {
             const wasAborted =
               abortController.signal.aborted ||
@@ -19139,6 +19945,7 @@ async function handleApi(req, res, url) {
                 reason: "agent-stopped",
                 sessionId,
               });
+              broadcastSessionsSnapshot();
               return;
             }
             // Record error as system message so user sees feedback
@@ -19150,6 +19957,7 @@ async function handleApi(req, res, url) {
             });
             tracker.updateSessionStatus(sessionId, "failed");
             broadcastUiEvent(["sessions"], "invalidate", { reason: "agent-error", sessionId });
+            broadcastSessionsSnapshot();
           }).finally(() => {
             // Clear only if this turn still owns the session abort controller.
             if (sessionRunAbortControllers.get(sessionId) === abortController) {
@@ -19176,6 +19984,7 @@ async function handleApi(req, res, url) {
           });
           jsonResponse(res, 200, { ok: true, messageId, warning: "no_agent_available" });
           broadcastUiEvent(["sessions"], "invalidate", { reason: "session-message", sessionId });
+          broadcastSessionsSnapshot();
         }
       } catch (err) {
         console.error("[ui-server] session message failed for %s: %s", String(sessionId), String(err?.message || err || "unknown"));
@@ -19215,6 +20024,7 @@ async function handleApi(req, res, url) {
           reason: "session-message-edited",
           sessionId,
         });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19234,6 +20044,24 @@ async function handleApi(req, res, url) {
           reason: "session-archived",
           sessionId,
         });
+        broadcastSessionsSnapshot();
+      } catch (err) {
+        jsonResponse(res, 500, { ok: false, error: err.message });
+      }
+      return;
+    }
+
+    if (action === "pause" && req.method === "POST") {
+      try {
+        const session = getScopedSession();
+        if (!session) {
+          jsonResponse(res, 404, { ok: false, error: "Session not found" });
+          return;
+        }
+        tracker.updateSessionStatus(sessionId, "paused");
+        jsonResponse(res, 200, { ok: true });
+        broadcastUiEvent(["sessions"], "invalidate", { reason: "session-paused", sessionId });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19250,6 +20078,7 @@ async function handleApi(req, res, url) {
         tracker.updateSessionStatus(sessionId, "active");
         jsonResponse(res, 200, { ok: true });
         broadcastUiEvent(["sessions"], "invalidate", { reason: "session-resumed", sessionId });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19269,6 +20098,7 @@ async function handleApi(req, res, url) {
           reason: "session-deleted",
           sessionId,
         });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19291,6 +20121,7 @@ async function handleApi(req, res, url) {
         tracker.renameSession(sessionId, title);
         jsonResponse(res, 200, { ok: true });
         broadcastUiEvent(["sessions"], "invalidate", { reason: "session-renamed", sessionId });
+        broadcastSessionsSnapshot();
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -19320,10 +20151,20 @@ async function handleApi(req, res, url) {
           jsonResponse(res, 200, { ok: true, diff: { files: [], totalFiles: 0, totalAdditions: 0, totalDeletions: 0, formatted: "(no worktree)" }, summary: "(no worktree)", commits: [] });
           return;
         }
-        const stats = collectDiffStats(worktreePath);
-        const summary = getCompactDiffSummary(worktreePath);
+        const stats = collectDiffStats(worktreePath, { includePatch: true });
+        const summary = stats.formatted || getCompactDiffSummary(worktreePath);
         const commits = getRecentCommits(worktreePath);
-        jsonResponse(res, 200, { ok: true, diff: stats, summary, commits });
+        jsonResponse(res, 200, {
+          ok: true,
+          diff: stats,
+          summary,
+          commits,
+          source: {
+            kind: "session",
+            label: stats.sourceRange || "origin/main...HEAD",
+            detail: worktreePath,
+          },
+        });
       } catch (err) {
         jsonResponse(res, 500, { ok: false, error: err.message });
       }
@@ -21052,13 +21893,45 @@ export async function startTelegramUiServer(options = {}) {
     wsServer = new WebSocketServer({ noServer: true });
     if (!sessionListenerAttached) {
       sessionListenerAttached = true;
-      addSessionEventListener((payload) => {
+      removeSessionEventListener = addSessionEventListener((payload) => {
         broadcastSessionMessage(payload);
       });
     }
+    if (!sessionStateListenerAttached) {
+      sessionStateListenerAttached = true;
+      removeSessionStateListener = addSessionStateListener((payload) => {
+        broadcastTuiSessionsSnapshot(payload?.reason || payload?.event?.reason || "updated", payload || {});
+      });
+    }
+    if (!activeSessionListenerAttached) {
+      activeSessionListenerAttached = true;
+      removeActiveSessionListener = addActiveSessionListener((sessions, detail = {}) => {
+        const snapshot = getCurrentSessionSnapshot();
+        broadcastCanonicalEvent(["sessions", "tui"], "sessions:update", snapshot);
+        if (detail?.taskKey) {
+          const session = snapshot.find((entry) => String(entry?.taskId || entry?.id || "").trim() === String(detail.taskKey || "").trim()) || {
+            id: String(detail.taskKey || "").trim(),
+            taskId: String(detail.taskKey || "").trim(),
+            type: "task",
+            status: "active",
+            lastActiveAt: new Date().toISOString(),
+            turnCount: 0,
+          };
+          broadcastCanonicalEvent(["sessions", "tui"], "session:event", buildSessionEventPayload({
+            sessionId: session?.id || detail.taskKey,
+            taskId: session?.taskId || detail.taskKey,
+            session,
+            event: {
+              kind: "state",
+              reason: detail?.reason || "update",
+            },
+          }));
+        }
+      });
+    }
     if (!sessionAccumulatorListenerAttached) {
       sessionAccumulatorListenerAttached = true;
-      addSessionAccumulationListener((payload) => {
+      removeSessionAccumulatorListener = addSessionAccumulationListener((payload) => {
         broadcastUiEvent(["tasks", "overview", "telemetry", "sessions"], "invalidate", {
           reason: "session-accumulated",
           taskId: payload?.taskId || null,
@@ -21068,22 +21941,16 @@ export async function startTelegramUiServer(options = {}) {
       });
     }
 
-    // Periodic stats broadcast for TUI
-    let statsBroadcastInterval = null;
-    function startStatsBroadcast() {
-      if (statsBroadcastInterval) return;
-      const intervalMs = Number(process.env.BOSUN_STATS_BROADCAST_MS) || 2000;
-      statsBroadcastInterval = setInterval(async () => {
-        try {
-          const stats = await collectUiStats();
-          broadcastUiEvent(["stats", "tui"], "stats", stats);
-        } catch (err) {
-          // best effort
-        }
-      }, intervalMs);
-      statsBroadcastInterval.unref?.();
-    }
-    startStatsBroadcast();
+    tuiStatsEmitter?.stop?.();
+    tuiStatsEmitter = createTuiStatsEmitter({
+      intervalMs: Number(process.env.BOSUN_STATS_BROADCAST_MS) || 2000,
+      getPayload: () => buildCurrentTuiMonitorStats(),
+      emit: (stats) => {
+        broadcastCanonicalEvent(["monitor", "stats", "tui"], "monitor:stats", stats);
+        broadcastUiEvent(["stats", "tui"], "stats", stats);
+      },
+    });
+    tuiStatsEmitter.start();
 
     // Retry queue tracking
     let _retryQueue = { count: 0, items: [] };
@@ -21118,10 +21985,7 @@ export async function startTelegramUiServer(options = {}) {
     let _activeSessions = [];
     function updateActiveSessions(sessions) {
       _activeSessions = sessions || [];
-      // Broadcast session updates
-      for (const session of _activeSessions) {
-        broadcastUiEvent(["sessions", "tui"], "session:update", session);
-      }
+      broadcastTuiSessionsSnapshot("active-sessions", { sessions: _activeSessions });
     }
 
     // Task CRUD events
@@ -21142,6 +22006,18 @@ export async function startTelegramUiServer(options = {}) {
         payload: { connected: true },
         ts: Date.now(),
       });
+      sendWsMessage(socket, {
+        type: "sessions:update",
+        channels: ["sessions", "tui"],
+        payload: getCurrentSessionSnapshot(),
+        ts: Date.now(),
+      });
+      sendWsMessage(socket, {
+        type: "monitor:stats",
+        channels: ["monitor", "stats", "tui"],
+        payload: buildCurrentTuiMonitorStats(),
+        ts: Date.now(),
+      });
 
       socket.on("message", (raw) => {
         try {
@@ -21637,9 +22513,24 @@ export function stopTelegramUiServer() {
   if (!uiServer) return;
   stopTunnel();
   stopWsHeartbeat();
+  _activeSessions = [];
   // Clear injected configDir so it does not leak between server lifecycles
   // (tests start/stop servers repeatedly with different config directories).
   delete uiDeps.configDir;
+  tuiStatsEmitter?.stop?.();
+  tuiStatsEmitter = null;
+  removeSessionEventListener?.();
+  removeSessionEventListener = null;
+  sessionListenerAttached = false;
+  removeSessionStateListener?.();
+  removeSessionStateListener = null;
+  sessionStateListenerAttached = false;
+  removeActiveSessionListener?.();
+  removeActiveSessionListener = null;
+  activeSessionListenerAttached = false;
+  removeSessionAccumulatorListener?.();
+  removeSessionAccumulatorListener = null;
+  sessionAccumulatorListenerAttached = false;
   for (const socket of wsClients) {
     try {
       stopLogStream(socket);
@@ -21674,3 +22565,6 @@ export function stopTelegramUiServer() {
 }
 
 export { getLocalLanIp };
+
+
+