bosun 0.41.7 → 0.41.9

package/desktop/preload.mjs

@@ -94,4 +94,23 @@ contextBridge.exposeInMainWorld("veDesktop", {
     setScope: (id, isGlobal) =>
       ipcRenderer.invoke("bosun:shortcuts:setScope", { id, isGlobal }),
   },
+
+  /**
+   * Remote connection settings API.
+   * Available in the renderer via `window.veDesktop.connection.*`
+   */
+  connection: {
+    /** Get the current remote connection config + active status. */
+    get: () => ipcRenderer.invoke("bosun:connection:get"),
+
+    /** Save remote connection config. { enabled, endpoint, apiKey } */
+    set: (config) => ipcRenderer.invoke("bosun:connection:set", config),
+
+    /** Test connectivity to a remote endpoint. { endpoint, apiKey } */
+    test: (endpoint, apiKey) =>
+      ipcRenderer.invoke("bosun:connection:test", { endpoint, apiKey }),
+
+    /** Open the interactive remote connection setup dialog. */
+    setup: () => ipcRenderer.invoke("bosun:connection:setup"),
+  },
 });

package/entrypoint.mjs

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+/**
+ * entrypoint.mjs — Unified Bosun entrypoint for Docker, Desktop, and CLI.
+ *
+ * This is the single process owner for all Bosun child processes.
+ * It starts the unified UI server (which includes setup wizard if needed),
+ * spawns the monitor loop as a managed child, handles SIGTERM/SIGINT
+ * gracefully, and provides a /healthz endpoint.
+ *
+ * Environment detection:
+ *   BOSUN_DOCKER=1   → container mode (bind 0.0.0.0, logs to stdout, tini as PID 1)
+ *   BOSUN_DESKTOP=1  → Electron mode (bind 127.0.0.1, auto-open browser)
+ *   (neither)        → bare CLI mode
+ *
+ * Usage:
+ *   node entrypoint.mjs                    # default start
+ *   BOSUN_DOCKER=1 node entrypoint.mjs     # Docker container
+ *   BOSUN_DESKTOP=1 node entrypoint.mjs    # Desktop app
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  getHealthStatus,
+  markSetupComplete as _markSetupComplete,
+  setComponentStatus,
+  setShuttingDown,
+  setMonitorCircuitBroken,
+  setMode,
+} from "./infra/health-status.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const TAG = "[entrypoint]";
+const isDocker = process.env.BOSUN_DOCKER === "1";
+const isDesktop = process.env.BOSUN_DESKTOP === "1";
+
+// Synchronise mode flags with the shared health module
+setMode({ docker: isDocker, desktop: isDesktop });
+
+// ── Data directory resolution ───────────────────────────────────────────────
+// In Docker: /data (volume mount)
+// Otherwise: respect BOSUN_HOME / BOSUN_DIR, or let config.mjs resolve
+function resolveDataDir() {
+  if (isDocker) {
+    const dataDir = process.env.BOSUN_HOME || "/data";
+    process.env.BOSUN_HOME = dataDir;
+    process.env.BOSUN_DIR = dataDir;
+    return dataDir;
+  }
+  return process.env.BOSUN_HOME || process.env.BOSUN_DIR || "";
+}
+
+// ── Child process management ────────────────────────────────────────────────
+
+/** @type {Map<string, import("node:child_process").ChildProcess>} */
+const children = new Map();
+
+/** @type {boolean} */
+let shuttingDown = false;
+
+/** @type {boolean} */
+let setupComplete = false;
+
+// Track monitor crash history for circuit breaker
+const monitorCrashTimestamps = [];
+const MONITOR_CIRCUIT_BREAKER_WINDOW_MS = 60_000;
+const MONITOR_CIRCUIT_BREAKER_MAX_CRASHES = 3;
+let monitorCircuitBroken = false;
+
+/**
+ * Spawn a managed child process.
+ * @param {string} name - Human label for logs
+ * @param {string} script - Path to the script to run
+ * @param {string[]} args - Arguments
+ * @param {object} [opts] - spawn options overrides
+ * @returns {import("node:child_process").ChildProcess}
+ */
+function spawnChild(name, script, args = [], opts = {}) {
+  if (shuttingDown) return null;
+
+  const child = spawn(process.execPath, [script, ...args], {
+    cwd: opts.cwd || __dirname,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...opts.env },
+  });
+
+  children.set(name, child);
+  setComponentStatus(name, "running");
+
+  child.stdout?.on("data", (chunk) => {
+    process.stdout.write(chunk);
+  });
+  child.stderr?.on("data", (chunk) => {
+    process.stderr.write(chunk);
+  });
+
+  child.on("exit", (code, signal) => {
+    children.delete(name);
+    setComponentStatus(name, "stopped");
+
+    if (shuttingDown) {
+      console.log(`${TAG} ${name} exited (shutdown)`);
+      return;
+    }
+
+    console.warn(`${TAG} ${name} exited (code=${code} signal=${signal})`);
+
+    // Self-restart exit code (75) means monitor wants a clean re-fork
+    if (name === "monitor" && code === 75) {
+      console.log(`${TAG} monitor requested restart (exit code 75)`);
+      startMonitor();
+      return;
+    }
+
+    // Circuit breaker for monitor crashes
+    if (name === "monitor") {
+      const now = Date.now();
+      monitorCrashTimestamps.push(now);
+      // Trim old entries outside window
+      while (
+        monitorCrashTimestamps.length > 0 &&
+        now - monitorCrashTimestamps[0] > MONITOR_CIRCUIT_BREAKER_WINDOW_MS
+      ) {
+        monitorCrashTimestamps.shift();
+      }
+      if (monitorCrashTimestamps.length >= MONITOR_CIRCUIT_BREAKER_MAX_CRASHES) {
+        monitorCircuitBroken = true;
+        setMonitorCircuitBroken(true);
+        console.error(
+          `${TAG} monitor circuit breaker tripped: ${monitorCrashTimestamps.length} crashes in ${MONITOR_CIRCUIT_BREAKER_WINDOW_MS / 1000}s — stopping restarts`,
+        );
+        return;
+      }
+
+      // Restart with backoff
+      const delay = Math.min(5000 * monitorCrashTimestamps.length, 30_000);
+      console.log(`${TAG} restarting monitor in ${delay}ms`);
+      setTimeout(() => startMonitor(), delay);
+    }
+  });
+
+  child.on("error", (err) => {
+    console.error(`${TAG} ${name} spawn error: ${err.message}`);
+    children.delete(name);
+    setComponentStatus(name, "error");
+  });
+
+  return child;
+}
+
+// ── Monitor lifecycle ───────────────────────────────────────────────────────
+
+function startMonitor() {
+  if (shuttingDown || monitorCircuitBroken) return;
+  if (children.has("monitor")) return;
+
+  const monitorScript = resolve(__dirname, "infra", "monitor.mjs");
+  if (!existsSync(monitorScript)) {
+    console.error(`${TAG} monitor script not found: ${monitorScript}`);
+    setComponentStatus("monitor", "error");
+    return;
+  }
+
+  const monitorArgs = [];
+  // Pass through relevant CLI args
+  if (process.env.BOSUN_DIR) {
+    monitorArgs.push("--config-dir", process.env.BOSUN_DIR);
+  }
+
+  console.log(`${TAG} starting monitor`);
+  spawnChild("monitor", monitorScript, monitorArgs);
+}
+
+// ── Graceful shutdown ───────────────────────────────────────────────────────
+
+const SHUTDOWN_TIMEOUT_MS = 30_000;
+
+async function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  setShuttingDown(true);
+  console.log(`${TAG} ${signal} received — shutting down`);
+
+  // Send SIGTERM to all children
+  for (const [name, child] of children.entries()) {
+    console.log(`${TAG} sending SIGTERM to ${name} (pid=${child.pid})`);
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      /* best effort */
+    }
+  }
+
+  // Wait for children to exit, with a hard timeout
+  const deadline = Date.now() + SHUTDOWN_TIMEOUT_MS;
+  while (children.size > 0 && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 500));
+  }
+
+  // SIGKILL any stragglers
+  for (const [name, child] of children.entries()) {
+    console.warn(`${TAG} force-killing ${name} (pid=${child.pid})`);
+    try {
+      child.kill("SIGKILL");
+    } catch {
+      /* best effort */
+    }
+  }
+
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+
+// Windows: ensure cleanup on exit
+process.on("exit", () => {
+  for (const [, child] of children.entries()) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      /* best effort */
+    }
+  }
+});
+
+// ── Health endpoint ─────────────────────────────────────────────────────────
+// Re-export from the side-effect-free health module so existing callers
+// that import from entrypoint.mjs keep working.
+export { getHealthStatus } from "./infra/health-status.mjs";
+
+/**
+ * Mark setup as complete (called from ui-server when setup finishes).
+ */
+export function markSetupComplete() {
+  const wasSetupComplete = setupComplete;
+  setupComplete = true;
+  _markSetupComplete();
+
+  // If we just transitioned from "not complete" to "complete", and the process
+  // is still running, ensure the monitor is started when not already running.
+  if (!wasSetupComplete && !shuttingDown && !children.has("monitor")) {
+    try {
+      startMonitor();
+    } catch (err) {
+      // Log but do not crash if automatic monitor start fails
+      console.error(
+        `${TAG} failed to start monitor after setup completion: ${
+          err && err.message ? err.message : err
+        }`,
+      );
+    }
+  }
+}
+
+// ── Main startup ────────────────────────────────────────────────────────────
+
+async function main() {
+  const dataDir = resolveDataDir();
+
+  console.log(`${TAG} starting bosun`);
+  console.log(`${TAG} mode: ${isDocker ? "docker" : isDesktop ? "desktop" : "cli"}`);
+  if (dataDir) {
+    console.log(`${TAG} data dir: ${dataDir}`);
+    // Ensure data directory exists
+    mkdirSync(dataDir, { recursive: true });
+  }
+
+  // ── Check if setup is needed ──────────────────────────────────────────
+  try {
+    const { shouldRunSetup } = await import("./setup.mjs");
+    setupComplete = !shouldRunSetup();
+    if (setupComplete) _markSetupComplete();
+  } catch {
+    // If setup.mjs fails to load, assume setup is needed
+    setupComplete = false;
+  }
+
+  // ── Start the unified UI server ───────────────────────────────────────
+  // The ui-server now handles both /setup (wizard) and / (portal)
+  try {
+    const { startTelegramUiServer } = await import("./server/ui-server.mjs");
+
+    const host = isDocker ? "0.0.0.0" : isDesktop ? "127.0.0.1" : undefined;
+    const port = Number(process.env.BOSUN_PORT || process.env.PORT || process.env.TELEGRAM_UI_PORT || "") || 3080;
+
+    const server = await startTelegramUiServer({
+      host,
+      port,
+      // Pass setup state so ui-server knows whether to redirect to /setup
+      setupMode: !setupComplete,
+    });
+
+    if (server) {
+      setComponentStatus("server", "running");
+      console.log(`${TAG} ui server started`);
+    } else {
+      console.warn(`${TAG} ui server returned null — may be a duplicate instance`);
+      setComponentStatus("server", "error");
+    }
+  } catch (err) {
+    console.error(`${TAG} failed to start ui server: ${err.message}`);
+    setComponentStatus("server", "error");
+  }
+
+  // ── Start monitor (only if setup is complete) ─────────────────────────
+  if (setupComplete) {
+    startMonitor();
+  } else {
+    console.log(`${TAG} setup not complete — monitor will start after setup finishes`);
+  }
+
+  // In Docker mode, log to stdout that we're ready
+  if (isDocker) {
+    console.log(`${TAG} container ready`);
+  }
+}
+
+// ── Entry ───────────────────────────────────────────────────────────────────
+
+if (process.argv[1] === __filename) {
+  main().catch((err) => {
+    console.error(`${TAG} fatal: ${err.message}`);
+    console.error(err.stack);
+    process.exit(1);
+  });
+}

package/infra/health-status.mjs

@@ -0,0 +1,72 @@
+/**
+ * health-status.mjs — Side-effect-free module for Bosun health reporting.
+ *
+ * This module is safe to import from any context (ui-server, entrypoint, tests)
+ * without triggering process spawning or other startup side effects.
+ */
+
+const TAG = "[health-status]";
+
+/** @type {{ monitor: string, server: string }} */
+const componentStatus = {
+  monitor: "stopped",
+  server: "stopped",
+};
+
+let shuttingDown = false;
+let setupComplete = false;
+let monitorCircuitBroken = false;
+const startedAt = Date.now();
+let isDocker = process.env.BOSUN_DOCKER === "1";
+let isDesktop = process.env.BOSUN_DESKTOP === "1";
+
+/**
+ * Returns current health status object.
+ * @returns {object}
+ */
+export function getHealthStatus() {
+  return {
+    status: shuttingDown ? "shutting_down" : monitorCircuitBroken ? "degraded" : "ok",
+    setup: setupComplete,
+    monitor: componentStatus.monitor,
+    server: componentStatus.server,
+    uptime: Math.floor((Date.now() - startedAt) / 1000),
+    docker: isDocker,
+    desktop: isDesktop,
+  };
+}
+
+/**
+ * Update a named component's status.
+ * @param {string} name
+ * @param {string} status
+ */
+export function setComponentStatus(name, status) {
+  componentStatus[name] = status;
+}
+
+/** Mark setup as complete. */
+export function markSetupComplete() {
+  setupComplete = true;
+}
+
+/** @returns {boolean} */
+export function isSetupComplete() {
+  return setupComplete;
+}
+
+/** Mark the process as shutting down. */
+export function setShuttingDown(value = true) {
+  shuttingDown = value;
+}
+
+/** Mark the monitor circuit breaker as tripped. */
+export function setMonitorCircuitBroken(value = true) {
+  monitorCircuitBroken = value;
+}
+
+/** Allow callers (entrypoint) to override mode flags after env detection. */
+export function setMode({ docker, desktop } = {}) {
+  if (docker !== undefined) isDocker = Boolean(docker);
+  if (desktop !== undefined) isDesktop = Boolean(desktop);
+}

package/infra/library-manager.mjs

@@ -200,6 +200,58 @@ const FRAMEWORK_DOMAIN_MAP = Object.freeze({
 
 /** Resource types managed by the library */
 export const RESOURCE_TYPES = Object.freeze(["prompt", "agent", "skill", "mcp", "custom-tool"]);
+export const AGENT_LIBRARY_CATEGORIES = Object.freeze(["task", "interactive", "voice"]);
+export const INTERACTIVE_AGENT_MODES = Object.freeze(["ask", "agent", "plan", "web", "instant", "custom", "voice"]);
+
+export function normalizeAgentProfileType(rawType, options = {}) {
+  const value = String(rawType || "").trim().toLowerCase();
+  if (value === "voice" || value === "task" || value === "chat") return value;
+  if (options?.voiceAgent === true) return "voice";
+  return "task";
+}
+
+export function normalizeAgentLibraryCategory(rawCategory, options = {}) {
+  const value = String(rawCategory || "").trim().toLowerCase();
+  if (AGENT_LIBRARY_CATEGORIES.includes(value)) return value;
+  const profileType = normalizeAgentProfileType(options?.agentType, { voiceAgent: options?.voiceAgent });
+  if (profileType === "voice") return "voice";
+  if (profileType === "chat") return "interactive";
+  return "task";
+}
+
+export function normalizeInteractiveAgentMode(rawMode, options = {}) {
+  const value = String(rawMode || "").trim().toLowerCase();
+  if (INTERACTIVE_AGENT_MODES.includes(value)) return value;
+  if (options?.agentCategory === "voice") return "voice";
+  if (options?.agentCategory === "interactive") return "agent";
+  return "";
+}
+
+export function resolveAgentProfileLibraryMetadata(entry, profile = {}) {
+  const agentType = normalizeAgentProfileType(profile?.agentType, {
+    voiceAgent: profile?.voiceAgent === true,
+  });
+  const agentCategory = normalizeAgentLibraryCategory(profile?.agentCategory, {
+    agentType,
+    voiceAgent: profile?.voiceAgent === true,
+  });
+  const interactiveMode = normalizeInteractiveAgentMode(
+    profile?.interactiveMode || profile?.chatMode,
+    { agentCategory },
+  );
+  const interactiveLabel = String(profile?.interactiveLabel || "").trim();
+  const explicitDropdown = profile?.showInChatDropdown;
+  const showInChatDropdown = agentCategory === "interactive"
+    ? explicitDropdown === true
+    : false;
+  return {
+    agentType,
+    agentCategory,
+    interactiveMode: interactiveMode || null,
+    interactiveLabel: interactiveLabel || null,
+    showInChatDropdown,
+  };
+}
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -497,10 +549,11 @@ function updateSkillEntryIndexCache(rootDir, index, manifestMtimeMs = 0) {
 function buildIndexedAgentProfile(rootDir, entry) {
   const profile = getEntryContent(rootDir, entry);
   if (!profile || typeof profile !== "object") return null;
+  const metadata = resolveAgentProfileLibraryMetadata(entry, profile);
   return {
     ...entry,
     profile,
-    agentType: String(profile?.agentType || "task").trim().toLowerCase() || "task",
+    ...metadata,
     titlePatterns: toStringArray(profile?.titlePatterns),
     scopes: toStringArray(profile?.scopes),
     tags: uniqueStrings([...(entry?.tags || []), ...toStringArray(profile?.tags)]),
@@ -1129,6 +1182,10 @@ export function resolveLibraryPlan(rootDir, criteria = {}, opts = {}) {
  * @property {Object} [env]              - extra env vars for the agent
  * @property {string[]} [enabledTools]   - list of tool IDs enabled for this agent (null = all)
  * @property {string[]} [enabledMcpServers] - list of MCP server IDs enabled for this agent
+ * @property {"task"|"interactive"|"voice"} [agentCategory] - library grouping/category for the profile
+ * @property {"ask"|"agent"|"plan"|"web"|"instant"|"custom"|"voice"} [interactiveMode] - preferred manual interaction mode
+ * @property {string} [interactiveLabel] - custom label shown for manual agent type/grouping
+ * @property {boolean} [showInChatDropdown] - whether this interactive profile is shown in the chat manual-agent dropdown
  */
 
 /**

package/infra/maintenance.mjs

@@ -1355,7 +1355,7 @@ export async function runMaintenanceSweep(opts = {}) {
 
   // Guard against core.bare=true corruption that accumulates from worktree ops
   try {
-    const repoRoot = resolve(import.meta.dirname || ".", "..", "..");
+    const repoRoot = resolve(import.meta.dirname || ".", "..");
     fixGitConfigCorruption(repoRoot);
   } catch {
     /* best-effort */
@@ -1389,4 +1389,3 @@ export async function runMaintenanceSweep(opts = {}) {
 
   return result;
 }
-

package/infra/monitor.mjs

@@ -510,17 +510,24 @@ async function ensureWorkflowAutomationEngine() {
       }
 
       const kanbanService = {
-        createTask: async (taskData = {}) => {
+        createTask: async (projectIdOrTaskData = {}, taskDataArg = undefined) => {
+          const invokedWithProjectId = typeof projectIdOrTaskData === "string";
+          const payloadCandidate = invokedWithProjectId ? taskDataArg : projectIdOrTaskData;
+          const payload =
+            payloadCandidate && typeof payloadCandidate === "object" && !Array.isArray(payloadCandidate)
+              ? { ...payloadCandidate }
+              : {};
           const backend = getActiveKanbanBackend();
           const projectId = String(
-            taskData?.projectId || getConfiguredKanbanProjectId(backend) || "",
+            (invokedWithProjectId ? projectIdOrTaskData : payload?.projectId) ||
+              getConfiguredKanbanProjectId(backend) ||
+              "",
           ).trim();
           if (!projectId) {
             throw new Error(
               `No project ID configured for backend=${backend} (required for workflow action.create_task)`,
             );
           }
-          const payload = { ...(taskData || {}) };
           delete payload.projectId;
           return createTask(projectId, payload);
         },
@@ -1720,8 +1727,8 @@ configureExecutorTaskStatusTransitions();
   }
 }
 
-// Guard against core.bare=true corruption on the main repo at startup
-fixGitConfigCorruption(resolve(__dirname, "..", ".."));
+// Guard against core.bare=true corruption on the Bosun repo at startup.
+fixGitConfigCorruption(resolve(__dirname, ".."));
 
 function canSignalProcess(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
@@ -13284,8 +13291,15 @@ async function startProcess() {
             .catch((err) =>
               console.warn(
                 `[workspace-monitor] failed to start for ${shortId}: ${err.message}`,
-              ),
-            );
+            ),
+          );
+        }
+        if (
+          typeof engine.load === "function" &&
+          ((Array.isArray(reconcile?.updatedWorkflowIds) && reconcile.updatedWorkflowIds.length > 0) ||
+            Number(reconcile?.metadataUpdated || 0) > 0)
+        ) {
+          engine.load();
         }
       }
 
@@ -15509,6 +15523,8 @@ if (isExecutorDisabled()) {
         getTask: (taskId) => getInternalTask(taskId),
         setTaskStatus: (taskId, status, source) =>
           setInternalTaskStatus(taskId, status, source),
+        updateTask: (taskId, updates) =>
+          updateInternalTask(taskId, updates),
         // broadcastUiEvent is wired later when UI server starts via
         // injectUiDependencies → setBroadcastFn pattern
       });
@@ -15534,6 +15550,8 @@ if (isExecutorDisabled()) {
         getTask: (taskId) => getInternalTask(taskId),
         setTaskStatus: (taskId, status, source) =>
           setInternalTaskStatus(taskId, status, source),
+        updateTask: (taskId, updates) =>
+          updateInternalTask(taskId, updates),
         assessIntervalMs: 30_000,
         // ── Intervention callbacks (steering, thread management) ──
         forceNewThread: (taskId, reason) => {

package/infra/session-tracker.mjs

@@ -12,7 +12,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { resolve, dirname, sep } from "node:path";
 import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { buildSessionInsights } from "../lib/session-insights.mjs";
@@ -20,7 +20,20 @@ import { isTestRuntime } from "./test-runtime.mjs";
 import { addCompletedSession } from "./runtime-accumulator.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SESSIONS_DIR = resolve(__dirname, "..", "logs", "sessions");
+const WORKSPACE_MIRROR_MARKER = `${sep}.bosun${sep}workspaces${sep}`.toLowerCase();
+
+function resolveSessionTrackerSourceRepoRoot(startDir = __dirname) {
+  const normalized = resolve(startDir);
+  const lower = normalized.toLowerCase();
+  const mirrorIndex = lower.indexOf(WORKSPACE_MIRROR_MARKER);
+  if (mirrorIndex >= 0) {
+    return normalized.slice(0, mirrorIndex);
+  }
+  return resolve(normalized, "..");
+}
+
+const SESSION_TRACKER_REPO_ROOT = resolveSessionTrackerSourceRepoRoot(__dirname);
+const SESSIONS_DIR = resolve(SESSION_TRACKER_REPO_ROOT, "logs", "sessions");
 
 const TAG = "[session-tracker]";
 
@@ -56,6 +69,11 @@ function resolveSessionTrackerPersistDir(options = {}) {
   return isTestRuntime() ? null : SESSIONS_DIR;
 }
 
+export const _test = Object.freeze({
+  resolveSessionTrackerSourceRepoRoot,
+  resolveSessionTrackerPersistDir,
+});
+
 function resolveSessionMaxMessages(type, metadata, explicitMax, fallbackMax) {
   if (Number.isFinite(explicitMax)) {
     return explicitMax > 0 ? explicitMax : 0;
@@ -575,18 +593,27 @@ export class SessionTracker {
   listAllSessions() {
     const list = [];
     for (const s of this.#sessions.values()) {
+      const progress = s.status === "active"
+        ? this.getProgressStatus(s.id || s.taskId)
+        : null;
+      const derivedStatus = progress?.status === "ended"
+        ? "completed"
+        : (progress?.status || s.status);
       list.push({
         id: s.id || s.taskId,
         taskId: s.taskId,
         title: s.taskTitle || s.title || null,
         type: s.type || "task",
-        status: s.status,
+        status: derivedStatus,
         workspaceId: String(s?.metadata?.workspaceId || "").trim() || null,
         workspaceDir: String(s?.metadata?.workspaceDir || "").trim() || null,
         branch: String(s?.metadata?.branch || "").trim() || null,
         turnCount: s.turnCount || 0,
         createdAt: s.createdAt || new Date(s.startedAt).toISOString(),
         lastActiveAt: s.lastActiveAt || new Date(s.lastActivityAt).toISOString(),
+        idleMs: progress?.idleMs ?? 0,
+        elapsedMs: progress?.elapsedMs ?? Math.max(0, Date.now() - Number(s.startedAt || Date.now())),
+        recommendation: progress?.recommendation || "none",
         preview: this.#lastMessagePreview(s),
         lastMessage: this.#lastMessagePreview(s),
         insights: s.insights || null,