@brainpilot/web 0.0.8 → 0.0.9

package/src/components/session/TimelineTab.tsx

@@ -15,6 +15,13 @@ import { getMessageEdge, msgTypeKind } from "./agentNetworkShared";
 interface TimelineTabProps {
   messages: ChatMessage[];
   now: number;
+  /**
+   * Whether the session is actively running (≥1 agent in a running state).
+   * Only while running does the axis track wall-clock `now` and show the
+   * live "now" marker; a finished session freezes the axis at the last
+   * message so the plot doesn't grow a blank right gutter over time (#166).
+   */
+  isRunning?: boolean;
   /** Click a dot → caller selects that agent (and flips to Detail tab). */
   onSelectMessage: (agentName: string) => void;
 }
@@ -33,7 +40,30 @@ const LABEL_W = 88;
 const PAD_TOP = 28;
 const TICK_COUNT = 6;
 
-export function TimelineTab({ messages, now, onSelectMessage }: TimelineTabProps) {
+/**
+ * Compute the timeline's [start, end] axis bounds (#166).
+ *
+ * The axis always starts at the first message. It ends at the LAST message,
+ * and only extends to wall-clock `now` while the session is actively running.
+ * A finished session therefore freezes its right edge at the last event
+ * instead of accreting blank space as real time marches on.
+ *
+ * `tsList` must be ascending (as produced by the sorted `dots`).
+ */
+export function computeTimeBounds(
+  tsList: number[],
+  now: number,
+  isRunning: boolean,
+): { start: number; end: number } {
+  if (tsList.length === 0) return { start: now - 60_000, end: now };
+  const start = tsList[0];
+  const lastTs = tsList[tsList.length - 1];
+  const end = isRunning ? Math.max(now, lastTs) : lastTs;
+  // Degenerate span (single dot / identical timestamps): give it a minute.
+  return { start, end: end === start ? start + 60_000 : end };
+}
+
+export function TimelineTab({ messages, now, isRunning = false, onSelectMessage }: TimelineTabProps) {
   const t = useT();
   const containerRef = useRef<HTMLDivElement | null>(null);
   const [zoom, setZoom] = useState(1);
@@ -78,12 +108,10 @@ export function TimelineTab({ messages, now, onSelectMessage }: TimelineTabProps
     return names;
   }, [dots]);
 
-  const timeBounds = useMemo(() => {
-    if (dots.length === 0) return { start: now - 60_000, end: now };
-    const start = dots[0].ts;
-    const end = Math.max(now, dots[dots.length - 1].ts);
-    return { start, end: end === start ? start + 60_000 : end };
-  }, [dots, now]);
+  const timeBounds = useMemo(
+    () => computeTimeBounds(dots.map((d) => d.ts), now, isRunning),
+    [dots, now, isRunning],
+  );
 
   if (dots.length === 0) {
     return (
@@ -243,8 +271,10 @@ export function TimelineTab({ messages, now, onSelectMessage }: TimelineTabProps
             </g>
           ))}
 
-          {/* "now" marker */}
-          <line x1={xOf(now)} x2={xOf(now)} y1={PAD_TOP - 6} y2={svgH - 4} className="agent-timeline__now" />
+          {/* "now" marker — only meaningful while the session is live (#166) */}
+          {isRunning && (
+            <line x1={xOf(now)} x2={xOf(now)} y1={PAD_TOP - 6} y2={svgH - 4} className="agent-timeline__now" />
+          )}
 
           {/* delegate→result arcs */}
           {arcs.map((a) => {

package/src/contexts/SessionContext.tsx

@@ -102,6 +102,25 @@ const SessionContext = createContext<SessionContextValue | null>(null);
 // CONTENT / END leaves old long sessions looking empty.
 const HISTORY_REHYDRATE_LIMIT = 0;
 
+/**
+ * #194-B1: merge the full rehydrated history under whatever the live message
+ * list already holds. On refresh the SSE ring-buffer tail seeds a few recent
+ * messages before history arrives; we must NOT discard the (complete) history
+ * just because the list is non-empty. The persisted history is the base; we
+ * append only the messages already shown that history doesn't contain (by id) —
+ * in-flight optimistic sends, or events newer than the persisted file. Ordering
+ * matters: history first (chronological), then the live-only tail.
+ */
+export function mergeRehydratedMessages(
+  existing: ChatMessage[],
+  history: ChatMessage[],
+): ChatMessage[] {
+  if (existing.length === 0) return history;
+  const historyIds = new Set(history.map((m) => m.id));
+  const extra = existing.filter((m) => !historyIds.has(m.id));
+  return [...history, ...extra];
+}
+
 function foldSessionHistory(events: unknown[], sessionId: string): {
   messages: ChatMessage[];
   trace: TraceGraph | null;
@@ -293,13 +312,18 @@ export function SessionProvider({ children }: { children: ReactNode }) {
         hydratedSessionsRef.current.add(sessionId);
         if (lastUsage) setTokenUsage(lastUsage);
 
-        // Only seed the message list if the user hasn't already started typing
-        // / receiving live SSE for this session in the brief window before
-        // history arrived (otherwise we'd clobber their in-flight messages).
-        setMessagesBySession((current) => {
-          if ((current[sessionId]?.length ?? 0) > 0) return current;
-          return { ...current, [sessionId]: nextMessages };
-        });
+        // Merge the full history under whatever SSE / optimistic messages have
+        // already landed — do NOT bail just because the list is non-empty
+        // (#194-B1). On refresh the SSE ring-buffer tail arrives first and seeds
+        // a few recent messages; the old `length > 0 → skip` guard then dropped
+        // the entire rehydrated history, leaving only those few. The persisted
+        // history is the complete log, so use it as the base and append only the
+        // messages SSE already showed that the history doesn't contain (by id) —
+        // in-flight optimistic sends, or events newer than the persisted file.
+        setMessagesBySession((current) => ({
+          ...current,
+          [sessionId]: mergeRehydratedMessages(current[sessionId] ?? [], nextMessages),
+        }));
         if (nextTrace) {
           setTraceBySession((current) =>
             current[sessionId] ? current : { ...current, [sessionId]: nextTrace! },

package/src/contexts/messageReducer.ts

@@ -171,6 +171,25 @@ export function reduceMessagesForEvent(existing: ChatMessage[], event: WebSocket
       // Strip NO-RENDER wrapper used by record_trace "Message Complete" hint
       delta = delta.replace(/<!--NO-RENDER-->[\s\S]*?<!--\/NO-RENDER-->/g, "");
       if (!delta) return existing;
+      // Orphaned CONTENT (no matching START) — recover gracefully instead of
+      // dropping it. This happens when a demo bundle was exported from a
+      // tail-sliced history: the leading START of the earliest messages is gone,
+      // and a plain `.map` here would no-op, silently swallowing the opening
+      // replies. Synthesize the message so the content still renders.
+      if (!existing.some((m) => m.id === id)) {
+        return [
+          ...existing,
+          {
+            id,
+            role: "assistant",
+            content: delta,
+            createdAt: new Date().toISOString(),
+            agent,
+            streaming: true,
+            kind: "text",
+          },
+        ];
+      }
       return existing.map((m) =>
         m.id === id ? { ...m, content: (m.content ?? "") + delta } : m,
       );

package/src/contracts/backend.ts

@@ -481,7 +481,14 @@ function normalizeStringArray(value: unknown): string[] {
 }
 
 function camelizeKey(key: string): string {
-  return key.replace(/_([a-z])/g, (_, char: string) => char.toUpperCase());
+  // Preserve a leading-underscore prefix: `_ts` / `_seq` are AG-UI transport
+  // metadata whose underscore is significant. Without this guard the regex
+  // turns `_ts` into `Ts`, so `normalizeAgUiEvent` strips the timestamp and the
+  // demo replay's timeline collapses (every event lands at ms=0). Only internal
+  // snake_case boundaries (e.g. `agent_name` → `agentName`) are camelized.
+  const lead = key.match(/^_+/)?.[0] ?? "";
+  const rest = key.slice(lead.length);
+  return lead + rest.replace(/_([a-z])/g, (_, char: string) => char.toUpperCase());
 }
 
 function camelizeObject(value: unknown): unknown {

package/src/i18n/messages/files.ts

@@ -17,6 +17,7 @@ export default defineMessages(
     "files.aria.tree": "文件树",
     "files.selectForDownload": "选择 {name} 以下载",
     "files.error.notRunning": "Sandbox 未运行，无法读取文件。",
+    "files.error.loadFailed": "加载文件列表失败",
     "files.error.downloadFailed": "下载文件失败",
     "files.error.refreshFailed": "刷新文件失败",
     "files.error.previewFailed": "无法预览文件",
@@ -56,6 +57,7 @@ export default defineMessages(
     "files.aria.tree": "File tree",
     "files.selectForDownload": "Select {name} for download",
     "files.error.notRunning": "Sandbox is not running; cannot read files.",
+    "files.error.loadFailed": "Failed to load file list",
     "files.error.downloadFailed": "Failed to download file",
     "files.error.refreshFailed": "Failed to refresh files",
     "files.error.previewFailed": "Unable to preview file",

package/src/utils/api.ts

@@ -123,6 +123,20 @@ export const api = {
     return handleJson(await apiFetch(`${API_BASE}/version`));
   },
 
+  // #156: real on-disk paths for the Files panel (local mode only). Hosted
+  // backends return `{ localMode: false }` with no host path. Best-effort:
+  // any failure resolves to a non-local shape so callers fall back cleanly.
+  async getInfo(): Promise<{ localMode: boolean; dataDir?: string; workspacesRoot?: string }> {
+    if (runtimeConfig.useMockBackend) {
+      return { localMode: false };
+    }
+    try {
+      return await handleJson(await apiFetch(`${API_BASE}/info`));
+    } catch {
+      return { localMode: false };
+    }
+  },
+
   auth: {
     async me(): Promise<User> {
       if (runtimeConfig.useMockBackend) {