@hienlh/ppm 0.17.55 → 0.17.57

package/src/services/subagent-transcript-merger.ts

@@ -0,0 +1,144 @@
+/**
+ * SubagentTranscriptMerger — restore Agent/Task card children on reload.
+ *
+ * Newer Claude Code CLIs no longer write subagent activity into the main
+ * session JSONL (no isSidechain lines, no parent_tool_use_id). Instead each
+ * agent gets its own transcript at:
+ *   ~/.claude/projects/<slug>/<sessionId>/subagents/agent-<id>.jsonl
+ * with a sibling agent-<id>.meta.json carrying the spawning Agent tool_use id.
+ *
+ * Without merging these, a reloaded session shows bare Agent cards and the
+ * live-streamed children are lost. This module reads the meta files, parses
+ * each agent transcript, and attaches its events as the card's children.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ChatEvent } from "../types/api.ts";
+import { parseSessionMessage } from "./jsonl-transcript-parser.ts";
+
+/**
+ * Locate the per-session directory (…/projects/<slug>/<sessionId>) that holds
+ * subagents/. The SDK encodes the cwd by replacing separators + drive colon
+ * with "-"; when that drifts (drive-letter case), fall back to scanning
+ * project dirs for the session's main JSONL.
+ */
+export function resolveSessionDir(sessionId: string, projectPath: string | null | undefined): string | null {
+  const home = homedir();
+  const projectsRoot = join(home, ".claude", "projects");
+  if (projectPath) {
+    const encoded = projectPath.replace(/[/\\:]/g, "-");
+    const dir = join(projectsRoot, encoded);
+    if (existsSync(join(dir, `${sessionId}.jsonl`))) return join(dir, sessionId);
+  }
+  try {
+    for (const entry of readdirSync(projectsRoot)) {
+      if (existsSync(join(projectsRoot, entry, `${sessionId}.jsonl`))) {
+        return join(projectsRoot, entry, sessionId);
+      }
+    }
+  } catch {
+    /* projects root unreadable */
+  }
+  return null;
+}
+
+interface MessageLike {
+  content: string;
+  events?: ChatEvent[];
+}
+
+/** Payload guards — a session can hold dozens of agents with multi-MB transcripts. */
+const MAX_CHILDREN_PER_AGENT = 2000;
+const MAX_CHILD_OUTPUT_CHARS = 50_000;
+
+/** Map of Agent-card toolUseId → agent transcript path, from subagents/*.meta.json */
+function indexAgentTranscripts(subagentsDir: string): Map<string, string> {
+  const map = new Map<string, string>();
+  let entries: string[];
+  try {
+    entries = readdirSync(subagentsDir);
+  } catch {
+    return map;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".meta.json")) continue;
+    try {
+      const meta = JSON.parse(readFileSync(join(subagentsDir, name), "utf8"));
+      const toolUseId = meta?.toolUseId as string | undefined;
+      if (!toolUseId) continue;
+      const transcript = join(subagentsDir, name.replace(/\.meta\.json$/, ".jsonl"));
+      if (existsSync(transcript)) map.set(toolUseId, transcript);
+    } catch {
+      /* unreadable meta — skip this agent */
+    }
+  }
+  return map;
+}
+
+/** Parse one agent transcript into a flat children event list (stream order). */
+function parseAgentTranscript(filePath: string): ChatEvent[] {
+  const children: ChatEvent[] = [];
+  let text: string;
+  try {
+    text = readFileSync(filePath, "utf8");
+  } catch {
+    return children;
+  }
+  let isFirstUser = true;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: any;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    if (!entry.message) continue;
+    if (children.length >= MAX_CHILDREN_PER_AGENT) break;
+    // The first user record is the agent's spawn prompt — the live stream
+    // never showed it as a child, so skip it to match the streaming view.
+    if (entry.type === "user" && isFirstUser) {
+      isFirstUser = false;
+      const content = entry.message?.content;
+      const hasToolResult = Array.isArray(content) && content.some((b: any) => b?.type === "tool_result");
+      if (!hasToolResult) continue;
+    }
+    const parsed = parseSessionMessage(entry);
+    for (const ev of parsed.events ?? []) {
+      // Keep single events from ballooning the history payload (agent files
+      // can carry multi-MB tool outputs the live stream also showed in full,
+      // but 24 agents × full outputs breaks mobile reloads).
+      if (ev.type === "tool_result" && typeof ev.output === "string" && ev.output.length > MAX_CHILD_OUTPUT_CHARS) {
+        ev.output = ev.output.slice(0, MAX_CHILD_OUTPUT_CHARS) + "\n… [truncated]";
+      }
+      children.push(ev);
+    }
+  }
+  return children;
+}
+
+/**
+ * Attach subagent transcript events as children of their Agent/Task cards.
+ * `sessionDir` is the per-session directory next to the main JSONL
+ * (…/projects/<slug>/<sessionId>). Existing children are replaced — the disk
+ * transcript is the complete record, while live-collected children may be a
+ * partial overlap. Mutates messages in-place.
+ */
+export function mergeSubagentChildren(sessionDir: string, messages: MessageLike[]): void {
+  const index = indexAgentTranscripts(join(sessionDir, "subagents"));
+  if (index.size === 0) return;
+
+  for (const msg of messages) {
+    for (const ev of msg.events ?? []) {
+      if (ev.type !== "tool_use" || (ev.tool !== "Agent" && ev.tool !== "Task") || !ev.toolUseId) continue;
+      const transcript = index.get(ev.toolUseId);
+      if (!transcript) continue;
+      const children = parseAgentTranscript(transcript);
+      if (children.length > 0) ev.children = children;
+    }
+  }
+}

package/src/web/app.tsx

@@ -16,8 +16,7 @@ import { useSettingsStore } from "@/stores/settings-store";
 import { useTheme } from "@/theme/use-theme";
 import { initShikiThemeSync, warmShiki } from "@/theme/adapters/shiki-adapter";
 import { initMonacoThemeSync } from "@/theme/adapters/monaco-adapter";
-import { getAuthToken, api, projectUrl } from "@/lib/api-client";
-import { useStreamingStore } from "@/stores/streaming-store";
+import { getAuthToken } from "@/lib/api-client";
 import { useUrlSync, parseUrlState, autoOpenFromUrl } from "@/hooks/use-url-sync";
 import { useGlobalKeybindings } from "@/hooks/use-global-keybindings";
 import { useNotificationBadge } from "@/hooks/use-notification-badge";
@@ -227,20 +226,6 @@ export function App() {
     });
   }, [authState, activeProject?.name]);
 
-  // Seed which sessions are mid-turn. Chat tabs mount lazily, and a session's
-  // phase otherwise only arrives over that tab's WebSocket — so without this a
-  // background turn shows no tab-strip spinner and no title indicator.
-  useEffect(() => {
-    if (authState !== "authenticated" || !activeProject?.name) return;
-    api
-      .get<{ sessionId: string }[]>(`${projectUrl(activeProject.name)}/chat/sessions/running`)
-      .then((running) => {
-        const { setStreaming } = useStreamingStore.getState();
-        for (const s of running) setStreaming(s.sessionId, true);
-      })
-      .catch(() => {}); // never block boot on the indicator
-  }, [authState, activeProject?.name]);
-
   // Keep-alive: mount workspace on first visit, never unmount
   useEffect(() => {
     const projectName = activeProject?.name ?? "__global__";

package/src/web/hooks/use-chat.ts

@@ -216,9 +216,10 @@ export function useChat(sessionId: string | null, providerId = "claude", project
   // Sync streaming state to global store (for favicon + tab icon indicators)
   useEffect(() => {
     if (!sessionId) return;
-    useStreamingStore.getState().setStreaming(sessionId, phase !== "idle");
+    // projectName tags the entry so a project-scoped sync can reconcile it.
+    useStreamingStore.getState().setStreaming(sessionId, phase !== "idle", projectName);
     return () => { useStreamingStore.getState().setStreaming(sessionId, false); };
-  }, [sessionId, phase]);
+  }, [sessionId, phase, projectName]);
 
   /**
    * Route a child event to its parent Agent/Task tool_use's children array.
@@ -363,7 +364,13 @@ export function useChat(sessionId: string | null, providerId = "claude", project
           syncMessages();
           break;
         }
-        if (pid && routeToFinalizedParent(ev as ChatEvent, pid)) break;
+        if (pid) {
+          // Parent card not found (e.g. replay raced the history fetch) — drop
+          // rather than rendering subagent output flat in the main transcript;
+          // the history merge restores it from the agent's disk transcript.
+          if (routeToFinalizedParent(ev as ChatEvent, pid)) { /* nested */ }
+          break;
+        }
         streamingContentRef.current += ev.content;
         streamingEventsRef.current.push(ev as ChatEvent);
         syncMessages();
@@ -376,7 +383,11 @@ export function useChat(sessionId: string | null, providerId = "claude", project
           syncMessages();
           break;
         }
-        if (pid && routeToFinalizedParent(ev as ChatEvent, pid)) break;
+        if (pid) {
+          // No parent found → drop (see text case) instead of flat-rendering.
+          if (routeToFinalizedParent(ev as ChatEvent, pid)) { /* nested */ }
+          break;
+        }
         streamingEventsRef.current.push(ev as ChatEvent);
         syncMessages();
         break;
@@ -394,7 +405,11 @@ export function useChat(sessionId: string | null, providerId = "claude", project
           syncMessages();
           break;
         }
-        if (pid && routeToFinalizedParent(ev as ChatEvent, pid)) break;
+        if (pid) {
+          // No parent found → drop (see text case) instead of flat-rendering.
+          if (routeToFinalizedParent(ev as ChatEvent, pid)) { /* nested */ }
+          break;
+        }
         const tuId = ev.toolUseId as string | undefined;
         upsertStreamingEvent((e) => !!tuId && e.type === "tool_use" && (e as any).toolUseId === tuId);
         syncMessages();
@@ -415,7 +430,11 @@ export function useChat(sessionId: string | null, providerId = "claude", project
           syncMessages();
           break;
         }
-        if (pid && routeToFinalizedParent(ev as ChatEvent, pid)) break;
+        if (pid) {
+          // No parent found → drop (see text case) instead of flat-rendering.
+          if (routeToFinalizedParent(ev as ChatEvent, pid)) { /* nested */ }
+          break;
+        }
         upsertStreamingEvent((e) => !!trId && e.type === "tool_result" && (e as any).toolUseId === trId);
         syncMessages();
         break;

package/src/web/hooks/use-global-events.ts

@@ -3,6 +3,7 @@ import { WsClient } from "@/lib/ws-client";
 import { getAuthToken } from "@/lib/api-client";
 import { useNotificationStore } from "@/stores/notification-store";
 import { useStreamingStore } from "@/stores/streaming-store";
+import { syncRunningSessions } from "@/lib/sync-running-sessions";
 
 /**
  * App-wide event bus client (`/ws/global`).
@@ -18,6 +19,9 @@ import { useStreamingStore } from "@/stores/streaming-store";
  * - `session:phase_changed` → keeps the tab-strip spinner and title indicator
  *   correct for sessions whose tab is not mounted, and — critically — clears them
  *   when the turn ends. Nothing else can: `useChat` only runs while mounted.
+ *   On every (re)connect the indicators are also reconciled against the server
+ *   registry, since a phase change that happened while this socket was down was
+ *   never delivered and would otherwise stick until a full reload.
  * - `jira:*` → re-dispatched as window events.
  *
  * Also tells the server which project to watch, so file watching follows the
@@ -53,6 +57,7 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
         if (projectRef.current) {
           client.send(JSON.stringify({ type: "watch", projectName: projectRef.current }));
         }
+        void syncRunningSessions(projectRef.current);
         return;
       }
 
@@ -73,8 +78,8 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
       }
 
       if (type === "session:phase_changed") {
-        const d = data as unknown as { sessionId: string; phase: string };
-        useStreamingStore.getState().setStreaming(d.sessionId, d.phase !== "idle");
+        const d = data as unknown as { sessionId: string; phase: string; projectName?: string };
+        useStreamingStore.getState().setStreaming(d.sessionId, d.phase !== "idle", d.projectName);
         return;
       }
 
@@ -97,5 +102,6 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
   useEffect(() => {
     if (!enabled || !projectName) return;
     clientRef.current?.send(JSON.stringify({ type: "watch", projectName }));
+    void syncRunningSessions(projectName);
   }, [enabled, projectName]);
 }

package/src/web/lib/sync-running-sessions.ts

@@ -0,0 +1,27 @@
+import { api, projectUrl } from "@/lib/api-client";
+import { useStreamingStore } from "@/stores/streaming-store";
+
+/**
+ * Reconcile a project's streaming indicators (tab-strip spinner, title/favicon)
+ * against the server's session registry.
+ *
+ * Runs on every `/ws/global` (re)connect and on project switch. Two gaps it
+ * closes, both of which nothing else can:
+ * - a turn running in a tab that is not mounted (tabs mount lazily, so its phase
+ *   never reaches this client) → indicator missing;
+ * - an `idle` broadcast that landed while the global socket was down → indicator
+ *   stuck on until a full page reload.
+ */
+export async function syncRunningSessions(projectName: string | undefined): Promise<void> {
+  if (!projectName) return;
+  try {
+    const running = await api.get<{ sessionId: string }[]>(
+      `${projectUrl(projectName)}/chat/sessions/running`,
+    );
+    useStreamingStore
+      .getState()
+      .replaceProjectStreaming(projectName, running.map((s) => s.sessionId));
+  } catch {
+    // Never block boot or a reconnect on an indicator.
+  }
+}

package/src/web/stores/streaming-store.ts

@@ -2,21 +2,43 @@ import { create } from "zustand";
 
 /** Tracks which chat sessions are currently streaming AI responses */
 interface StreamingStore {
-  /** Set of sessionIds that are actively streaming */
-  sessions: Set<string>;
+  /** sessionId → projectName ("" when unknown) for sessions actively streaming.
+   *  The project is recorded so a project-scoped sync can drop stale entries
+   *  without touching sessions that belong to another project. */
+  sessions: Map<string, string>;
   /** Mark a session as streaming or idle */
-  setStreaming: (sessionId: string, streaming: boolean) => void;
+  setStreaming: (sessionId: string, streaming: boolean, projectName?: string) => void;
+  /**
+   * Reconcile one project's streaming set against the server's registry, which
+   * is authoritative. Needed because an `idle` broadcast missed while
+   * `/ws/global` was down would otherwise leave a spinner running forever —
+   * nothing else ever clears it. Scoped per project: the running list only
+   * covers one project, so entries from other projects must survive.
+   */
+  replaceProjectStreaming: (projectName: string, sessionIds: string[]) => void;
 }
 
 export const useStreamingStore = create<StreamingStore>((set) => ({
-  sessions: new Set(),
-  setStreaming: (sessionId, streaming) =>
+  sessions: new Map(),
+  setStreaming: (sessionId, streaming, projectName) =>
     set((state) => {
-      const next = new Set(state.sessions);
-      if (streaming) next.add(sessionId);
+      const next = new Map(state.sessions);
+      // Keep a previously recorded project when a caller omits it, so the entry
+      // stays reconcilable.
+      if (streaming) next.set(sessionId, projectName ?? next.get(sessionId) ?? "");
       else next.delete(sessionId);
       return { sessions: next };
     }),
+  replaceProjectStreaming: (projectName, sessionIds) =>
+    set((state) => {
+      const running = new Set(sessionIds);
+      const next = new Map(state.sessions);
+      for (const [id, project] of state.sessions) {
+        if (project === projectName && !running.has(id)) next.delete(id);
+      }
+      for (const id of sessionIds) next.set(id, projectName);
+      return { sessions: next };
+    }),
 }));
 
 /** Selector: true if any session is streaming */