bosun 0.42.0 → 0.42.2

package/infra/session-tracker.mjs

@@ -114,6 +114,7 @@ function resolveSessionMaxMessages(type, metadata, explicitMax, fallbackMax) {
 const FLUSH_INTERVAL_MS = 2000;
 
 const SESSION_EVENT_LISTENERS = new Set();
+const SESSION_STATE_LISTENERS = new Set();
 
 export function addSessionEventListener(listener) {
   if (typeof listener !== "function") return () => {};
@@ -121,6 +122,12 @@ export function addSessionEventListener(listener) {
   return () => SESSION_EVENT_LISTENERS.delete(listener);
 }
 
+export function addSessionStateListener(listener) {
+  if (typeof listener !== "function") return () => {};
+  SESSION_STATE_LISTENERS.add(listener);
+  return () => SESSION_STATE_LISTENERS.delete(listener);
+}
+
 function emitSessionEvent(session, message) {
   if (!session || !message || SESSION_EVENT_LISTENERS.size === 0) return;
   const payload = {
@@ -145,6 +152,37 @@ function emitSessionEvent(session, message) {
   }
 }
 
+function emitSessionStateEvent(session, reason, extra = {}) {
+  if (!session || SESSION_STATE_LISTENERS.size === 0) return;
+  const normalizedReason = String(reason || "updated").trim() || "updated";
+  const payload = {
+    sessionId: session.id || session.taskId,
+    taskId: session.taskId || session.id,
+    reason: normalizedReason,
+    session: {
+      id: session.id || session.taskId,
+      taskId: session.taskId || session.id,
+      type: session.type || "task",
+      status: session.status || "active",
+      lastActiveAt: session.lastActiveAt || new Date().toISOString(),
+      turnCount: session.turnCount || 0,
+      title: session.taskTitle || session.title || null,
+    },
+    event: {
+      kind: "state",
+      reason: normalizedReason,
+      ...extra,
+    },
+  };
+  for (const listener of SESSION_STATE_LISTENERS) {
+    try {
+      listener(payload);
+    } catch {
+      // best-effort listeners
+    }
+  }
+}
+
 // ── SessionTracker Class ────────────────────────────────────────────────────
 
 export class SessionTracker {
@@ -226,8 +264,12 @@ export class SessionTracker {
       lastActivityAt: Date.now(),
       metadata: {},
       insights: buildSessionInsights({ messages: [] }),
+      trajectory: { version: 1, replayable: true, steps: [] },
+      summary: null,
     });
+    const session = this.#sessions.get(taskId);
     this.#markDirty(taskId);
+    emitSessionStateEvent(session, "session-created", { title: taskTitle || taskId });
   }
 
   /**
@@ -279,6 +321,7 @@ export class SessionTracker {
       if (Number.isFinite(maxMessages) && maxMessages > 0) {
         while (session.messages.length > maxMessages) session.messages.shift();
       }
+      this.#appendTrajectoryStep(session, event);
       this.#refreshDerivedState(session);
       this.#markDirty(taskId);
       emitSessionEvent(session, msg);
@@ -312,6 +355,7 @@ export class SessionTracker {
       if (Number.isFinite(maxMessages) && maxMessages > 0) {
         while (session.messages.length > maxMessages) session.messages.shift();
       }
+      this.#appendTrajectoryStep(session, event);
       this.#refreshDerivedState(session);
       this.#markDirty(taskId);
       emitSessionEvent(session, msg);
@@ -329,6 +373,7 @@ export class SessionTracker {
     if (Number.isFinite(maxMessages) && maxMessages > 0) {
       while (session.messages.length > maxMessages) session.messages.shift();
     }
+    this.#appendTrajectoryStep(session, event);
     this.#refreshDerivedState(session);
     this.#markDirty(taskId);
     emitSessionEvent(session, msg);
@@ -348,6 +393,7 @@ export class SessionTracker {
     this.#refreshDerivedState(session);
     this.#accumulateCompletedSession(session, taskId);
     this.#markDirty(taskId);
+    emitSessionStateEvent(session, "session-ended", { status });
   }
 
   /**
@@ -578,10 +624,13 @@ export class SessionTracker {
       metadata,
       maxMessages: resolvedMax,
       insights: buildSessionInsights({ messages: [] }),
+      trajectory: { version: 1, replayable: true, steps: [] },
+      summary: null,
     };
     this.#sessions.set(id, session);
     this.#markDirty(id);
     this.#flushDirty(); // immediate write for create
+    emitSessionStateEvent(session, "session-created");
     return session;
   }
 
@@ -599,18 +648,23 @@ export class SessionTracker {
       const derivedStatus = progress?.status === "ended"
         ? "completed"
         : (progress?.status || s.status);
+      const lastActiveAt = s.lastActiveAt || new Date(s.lastActivityAt).toISOString();
       list.push({
         id: s.id || s.taskId,
         taskId: s.taskId,
         title: s.taskTitle || s.title || null,
         type: s.type || "task",
         status: derivedStatus,
+        lifecycleStatus: s.status || "active",
+        runtimeState: progress?.status || null,
+        runtimeUpdatedAt: lastActiveAt,
+        runtimeIsLive: Boolean(progress && progress.status !== "ended" && progress.status !== "not_found"),
         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(),
+        lastActiveAt,
         idleMs: progress?.idleMs ?? 0,
         elapsedMs: progress?.elapsedMs ?? Math.max(0, Date.now() - Number(s.startedAt || Date.now())),
         recommendation: progress?.recommendation || "none",
@@ -658,6 +712,7 @@ export class SessionTracker {
     this.#refreshDerivedState(session);
     this.#accumulateCompletedSession(session, sessionId);
     this.#markDirty(sessionId);
+    emitSessionStateEvent(session, "session-status", { status });
   }
 
   /**
@@ -671,6 +726,7 @@ export class SessionTracker {
     session.taskTitle = newTitle;
     session.title = newTitle;
     this.#markDirty(sessionId);
+    emitSessionStateEvent(session, "session-renamed", { title: newTitle });
   }
 
   /**
@@ -748,6 +804,13 @@ export class SessionTracker {
     this.#flushDirty();
   }
 
+  /**
+   * Flush all dirty sessions to disk immediately (alias for flush).
+   */
+  flushNow() {
+    this.#flushDirty();
+  }
+
   /**
    * Stop all timers and flush pending writes (for cleanup).
    */
@@ -894,6 +957,7 @@ export class SessionTracker {
         this.#refreshDerivedState(session);
         this.#accumulateCompletedSession(session, id);
         this.#markDirty(id);
+        emitSessionStateEvent(session, "session-idle-timeout", { status: session.status, idleMs });
         reaped++;
       }
     }
@@ -953,6 +1017,84 @@ export class SessionTracker {
     return true;
   }
 
+  #appendTrajectoryStep(session, event) {
+    if (!session) return;
+    if (!session.trajectory) {
+      session.trajectory = { version: 1, replayable: true, steps: [] };
+    }
+    const step = this.#extractTrajectoryStep(event, session);
+    if (step) {
+      session.trajectory.steps.push(step);
+    }
+  }
+
+  #extractTrajectoryStep(event, session) {
+    const ts = new Date().toISOString();
+    const id = `step-${Date.now()}-${randomToken(6)}`;
+
+    // String event
+    if (typeof event === "string") {
+      return { id, kind: "system", summary: event.trim().slice(0, 200), timestamp: ts };
+    }
+
+    // Direct message format (role/content)
+    if (event?.role && event?.content !== undefined) {
+      const content = String(event.content).slice(0, 200);
+      const timestamp = event.timestamp || ts;
+      if (event.role === "user") return { id, kind: "user_message", summary: content, timestamp };
+      if (event.role === "assistant") return { id, kind: "assistant", summary: content, timestamp };
+      return { id, kind: event.role, summary: content, timestamp };
+    }
+
+    // SDK item.started events
+    if (event?.type === "item.started" && event?.item) {
+      const item = event.item;
+      if (item.type === "command_execution") {
+        return { id, kind: "tool_call", summary: `Ran ${item.command || "unknown"}`, timestamp: ts };
+      }
+      if (item.type === "reasoning") {
+        return { id, kind: "reasoning", summary: item.text || "", timestamp: ts };
+      }
+      if (item.type === "function_call" || item.type === "mcp_tool_call") {
+        return { id, kind: "tool_call", summary: `${item.name || "call"} ${item.arguments || ""}`.trim(), timestamp: ts };
+      }
+      return null;
+    }
+
+    // SDK item.completed events
+    if (event?.type === "item.completed" && event?.item) {
+      const item = event.item;
+      if (item.type === "reasoning") {
+        return { id, kind: "reasoning", summary: item.text || "", timestamp: ts };
+      }
+      if (item.type === "function_call" || item.type === "mcp_tool_call") {
+        return { id, kind: "tool_call", summary: `${item.name || "call"} ${item.arguments || ""}`.trim(), timestamp: ts };
+      }
+      if (item.type === "command_execution") {
+        const cmd = item.command || "";
+        const hasPriorStart = (session?.trajectory?.steps || []).some(
+          (s) => s.kind === "tool_call" && s.summary === `Ran ${cmd}`,
+        );
+        if (hasPriorStart) {
+          return { id, kind: "tool_result", summary: `${cmd} (exit ${item.exit_code ?? "?"})`, timestamp: ts };
+        }
+        return { id, kind: "command", summary: cmd, timestamp: ts };
+      }
+      if (item.type === "agent_message") {
+        return { id, kind: "assistant", summary: item.text || "", timestamp: ts };
+      }
+      return null;
+    }
+
+    // Assistant message events
+    if (event?.type === "assistant.message") {
+      const content = event?.data?.content || event?.content || "";
+      return { id, kind: "agent_message", summary: content.slice(0, 200), timestamp: ts };
+    }
+
+    return null;
+  }
+
   #refreshDerivedState(session) {
     if (!session) return;
     try {
@@ -963,6 +1105,22 @@ export class SessionTracker {
     } catch {
       // Inspector insights are best-effort only.
     }
+    try {
+      const steps = session.trajectory?.steps || [];
+      const totalSteps = steps.length;
+      const isFailed = session.status === "failed";
+      const isLong = totalSteps > 12;
+      const failedOrLongRun = isFailed || isLong;
+      const resumable = failedOrLongRun;
+      const shortSteps = steps.slice(-12).map((s) => ({ kind: s.kind, summary: s.summary }));
+      const latestStep =
+        steps.length > 0
+          ? { kind: steps[steps.length - 1].kind, summary: steps[steps.length - 1].summary }
+          : null;
+      session.summary = { failedOrLongRun, resumable, totalSteps, shortSteps, latestStep };
+    } catch {
+      // Summary computation is best-effort only.
+    }
   }
 
   #ensureDir() {
@@ -1002,6 +1160,8 @@ export class SessionTracker {
           messages: session.messages || [],
           metadata: session.metadata || {},
           insights: session.insights || null,
+          trajectory: session.trajectory || null,
+          summary: session.summary || null,
         };
         writeFileSync(filePath, JSON.stringify(data, null, 2));
       } catch (err) {
@@ -1081,6 +1241,8 @@ export class SessionTracker {
           lastActivityAt: lastActive || Date.now(),
           metadata: data.metadata || {},
           insights: data.insights || buildSessionInsights({ messages: data.messages || [] }),
+          trajectory: data.trajectory || { version: 1, replayable: true, steps: [] },
+          summary: data.summary || null,
         });
         const restored = this.#sessions.get(id);
         if (restored && isTerminalSessionStatus(restored.status) && !restored.accumulatedAt) {