@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/renderer/store/slices/teamSlice.ts

@@ -72,6 +72,7 @@ const logger = createLogger('teamSlice');
 
 const TEAM_GET_DATA_TIMEOUT_MS = 30_000;
 const TEAM_FETCH_TIMEOUT_MS = 30_000;
+export const TEAM_MESSAGES_PAGE_LIMIT = 20;
 const MEMBER_SPAWN_STATUSES_IPC_RETRY_BACKOFF_MS = 5_000;
 const TEAM_REFRESH_BURST_WINDOW_MS = 4_000;
 const MEMBER_SPAWN_UI_EQUAL_WARN_THROTTLE_MS = 2_000;
@@ -796,6 +797,8 @@ export interface TeamMessagesCacheEntry {
   loadingOlder: boolean;
   headHydrated: boolean;
   olderHydrated: boolean;
+  /** Epoch ms of last manual clear; messages with timestamp ≤ this are hidden from the view. */
+  clearedAt: number | null;
 }
 
 export interface RefreshTeamMessagesHeadResult {
@@ -815,6 +818,7 @@ const EMPTY_TEAM_MESSAGES_CACHE_ENTRY: TeamMessagesCacheEntry = {
   loadingOlder: false,
   headHydrated: false,
   olderHydrated: false,
+  clearedAt: null,
 };
 
 function createEmptyTeamMessagesCacheEntry(): TeamMessagesCacheEntry {
@@ -829,6 +833,7 @@ function createEmptyTeamMessagesCacheEntry(): TeamMessagesCacheEntry {
     loadingOlder: false,
     headHydrated: false,
     olderHydrated: false,
+    clearedAt: null,
   };
 }
 
@@ -1500,6 +1505,7 @@ const mergedMessagesSelectorCache = new Map<
   {
     canonicalRef: InboxMessage[];
     optimisticRef: InboxMessage[];
+    clearedAt: number | null;
     result: InboxMessage[];
   }
 >();
@@ -1733,15 +1739,23 @@ export function selectTeamMessages(
   const cached = mergedMessagesSelectorCache.get(teamName);
   if (
     cached?.canonicalRef === entry.canonicalMessages &&
-    cached.optimisticRef === entry.optimisticMessages
+    cached.optimisticRef === entry.optimisticMessages &&
+    cached.clearedAt === entry.clearedAt
   ) {
     return cached.result;
   }
 
-  const result = mergeTeamMessages(entry.canonicalMessages, entry.optimisticMessages);
+  let result = mergeTeamMessages(entry.canonicalMessages, entry.optimisticMessages);
+  // `!= null` treats both null and a missing/undefined field as "no cutoff", so
+  // legacy entries constructed before clearedAt existed are not accidentally emptied.
+  if (entry.clearedAt != null) {
+    const cutoff = entry.clearedAt;
+    result = result.filter((msg) => Date.parse(msg.timestamp) > cutoff);
+  }
   mergedMessagesSelectorCache.set(teamName, {
     canonicalRef: entry.canonicalMessages,
     optimisticRef: entry.optimisticMessages,
+    clearedAt: entry.clearedAt,
     result,
   });
   return result;
@@ -2070,6 +2084,7 @@ export interface TeamSlice {
   refreshTeamData: (teamName: string, opts?: RefreshTeamDataOptions) => Promise<void>;
   refreshTeamMessagesHead: (teamName: string) => Promise<RefreshTeamMessagesHeadResult>;
   loadOlderTeamMessages: (teamName: string) => Promise<void>;
+  clearTeamMessages: (teamName: string) => void;
   refreshMemberActivityMeta: (teamName: string) => Promise<void>;
   syncTeamPendingReplyRefresh: (
     teamName: string,
@@ -2079,6 +2094,15 @@ export interface TeamSlice {
   ) => void;
   sendTeamMessage: (teamName: string, request: SendMessageRequest) => Promise<SendMessageResult>;
   addOptimisticTeamMessage: (teamName: string, message: InboxMessage) => void;
+  /**
+   * Accumulate a streaming direct-CLI assistant reply token-by-token into an optimistic
+   * in-progress message keyed by `messageId`. The canonical reply (appended server-side
+   * with the same messageId) prunes this twin on the next inbox refresh — no duplicate.
+   */
+  appendStreamingTeamReply: (
+    teamName: string,
+    chunk: { messageId: string; delta: string; from: string; to?: string }
+  ) => void;
   crossTeamTargets: {
     teamName: string;
     displayName: string;
@@ -3322,12 +3346,20 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
       const prevByName = get().teamByName;
       const existingEntry = prevByName[teamName];
       const configColor = data.config.color;
+      // getData collapses config.name to the slug for a draft/partially-provisioned
+      // team (no team.json on disk). Prefer the summary's existing user-facing
+      // displayName in that case so the name never regresses to the slug.
+      const configName = data.config.name ?? '';
+      const resolvedDisplayName =
+        configName && configName !== teamName
+          ? configName
+          : existingEntry?.displayName || configName || teamName;
       if (configColor && (!existingEntry || existingEntry?.color !== configColor)) {
         const patched: TeamSummary = existingEntry
-          ? { ...existingEntry, color: configColor, displayName: data.config.name || teamName }
+          ? { ...existingEntry, color: configColor, displayName: resolvedDisplayName }
           : {
               teamName,
-              displayName: data.config.name || teamName,
+              displayName: resolvedDisplayName,
               description: data.config.description ?? '',
               color: configColor,
               memberCount: data.members.length,
@@ -3372,7 +3404,7 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
         await api.review.invalidateTaskChangeSummaries(teamName, invalidationState.taskIds);
       }
       // Sync tab label with the team's display name from config
-      const displayName = data.config.name || teamName;
+      const displayName = resolvedDisplayName;
       const allTabs = get().getAllPaneTabs();
       const relatedTabs = allTabs.filter(
         (tab) => (tab.type === 'team' || tab.type === 'graph') && tab.teamName === teamName
@@ -3668,7 +3700,7 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
 
       try {
         const page = await unwrapIpc('team:getMessagesPage', () =>
-          api.teams.getMessagesPage(teamName, { limit: 50 })
+          api.teams.getMessagesPage(teamName, { limit: TEAM_MESSAGES_PAGE_LIMIT })
         );
         if (!isTeamLocalStateEpochCurrent(teamName, teamStateEpoch)) {
           return {
@@ -3805,7 +3837,7 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
         const page = await unwrapIpc('team:getMessagesPage', () =>
           api.teams.getMessagesPage(teamName, {
             cursor: entry.nextCursor,
-            limit: 50,
+            limit: TEAM_MESSAGES_PAGE_LIMIT,
           })
         );
         if (!isTeamLocalStateEpochCurrent(teamName, teamStateEpoch)) {
@@ -3884,6 +3916,27 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
     return request;
   },
 
+  clearTeamMessages: (teamName: string) => {
+    const clearedAt = Date.now();
+    mergedMessagesSelectorCache.delete(teamName);
+    set((state) => {
+      const existing = getTeamMessagesCacheEntry(state, teamName);
+      // Keep canonical messages (so refetch comparison is stable) but mark a cutoff:
+      // any message with timestamp ≤ clearedAt is hidden from the view.
+      return {
+        teamMessagesByName: {
+          ...state.teamMessagesByName,
+          [teamName]: {
+            ...existing,
+            optimisticMessages: [],
+            clearedAt,
+            hasMore: false,
+          },
+        },
+      };
+    });
+  },
+
   refreshMemberActivityMeta: async (teamName: string) => {
     const entry = getTeamMessagesCacheEntry(get(), teamName);
     if (!entry.headHydrated) {
@@ -4112,6 +4165,43 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
       },
     }));
   },
+  appendStreamingTeamReply: (teamName, chunk) => {
+    const messageId = chunk.messageId.trim();
+    if (!messageId) return;
+    set((state) => {
+      const entry = getTeamMessagesCacheEntry(state, teamName);
+      const existingIndex = entry.optimisticMessages.findIndex(
+        (m) => typeof m.messageId === 'string' && m.messageId.trim() === messageId
+      );
+      let nextOptimistic: InboxMessage[];
+      if (existingIndex >= 0) {
+        // Append the delta to the in-progress reply (token-by-token accumulation).
+        const existing = entry.optimisticMessages[existingIndex];
+        nextOptimistic = [...entry.optimisticMessages];
+        nextOptimistic[existingIndex] = { ...existing, text: existing.text + chunk.delta };
+      } else {
+        nextOptimistic = [
+          ...entry.optimisticMessages,
+          {
+            from: chunk.from,
+            to: chunk.to,
+            text: chunk.delta,
+            timestamp: new Date().toISOString(),
+            read: true,
+            messageId,
+            source: 'runtime_delivery',
+          },
+        ];
+        nextOptimistic.sort(compareInboxMessagesByTimestamp);
+      }
+      return {
+        teamMessagesByName: {
+          ...state.teamMessagesByName,
+          [teamName]: { ...entry, optimisticMessages: nextOptimistic },
+        },
+      };
+    });
+  },
 
   fetchCrossTeamTargets: async () => {
     set({ crossTeamTargetsLoading: true });
@@ -4461,8 +4551,29 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
         );
       }
 
-      // Just create the team config — no provisioning, no launching.
-      await unwrapIpc('team:create', () => api.teams.createTeam(request));
+      const floor = nowIso();
+      set((state) => {
+        const previousRuntimeRunId = state.currentRuntimeRunIdByTeam[request.teamName];
+        return {
+          currentRuntimeRunIdByTeam:
+            omitTeamKey(state.currentRuntimeRunIdByTeam, request.teamName) ??
+            state.currentRuntimeRunIdByTeam,
+          ignoredRuntimeRunIds: previousRuntimeRunId
+            ? { ...state.ignoredRuntimeRunIds, [previousRuntimeRunId]: request.teamName }
+            : state.ignoredRuntimeRunIds,
+          provisioningStartedAtFloorByTeam: {
+            ...state.provisioningStartedAtFloorByTeam,
+            [request.teamName]: floor,
+          },
+          activeToolsByTeam:
+            omitTeamKey(state.activeToolsByTeam, request.teamName) ?? state.activeToolsByTeam,
+          finishedVisibleByTeam:
+            omitTeamKey(state.finishedVisibleByTeam, request.teamName) ??
+            state.finishedVisibleByTeam,
+          toolHistoryByTeam:
+            omitTeamKey(state.toolHistoryByTeam, request.teamName) ?? state.toolHistoryByTeam,
+        };
+      });
 
       // Persist per-team launch params (model, effort, limit context)
       const baseModel = extractBaseModel(request.model, request.providerId);
@@ -4475,6 +4586,12 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
         limitContext: request.limitContext ?? false,
       };
       saveLaunchParams(request.teamName, params);
+      set((state) => ({
+        launchParamsByTeam: {
+          ...state.launchParamsByTeam,
+          [request.teamName]: params,
+        },
+      }));
 
       // Initialize per-team tool approval settings based on skipPermissions flag
       const initialSettings: ToolApprovalSettings =
@@ -4483,6 +4600,18 @@ export const createTeamSlice: StateCreator<AppState, [], [], TeamSlice> = (set,
           : { ...DEFAULT_TOOL_APPROVAL_SETTINGS, autoAllowAll: true };
       saveToolApprovalSettingsForTeam(request.teamName, initialSettings);
 
+      const response = await unwrapIpc('team:create', () => api.teams.createTeam(request));
+      const runId =
+        typeof response === 'object' && response && 'runId' in response
+          ? String(response.runId)
+          : request.teamName;
+      set((state) => ({
+        currentRuntimeRunIdByTeam: {
+          ...state.currentRuntimeRunIdByTeam,
+          [request.teamName]: runId,
+        },
+      }));
+
       // Refresh team list to pick up the new team
       void get().fetchTeams();
       window.setTimeout(() => {

package/src/renderer/types/mention.ts

@@ -23,6 +23,14 @@ export interface MentionSuggestion {
   searchText?: string;
   /** Optional slash command string including leading slash (command and skill suggestions only) */
   command?: `/${string}`;
+  /** Optional canonical command reference for registry-backed slash commands */
+  commandRef?: string;
+  /** Workflow prompt id for slash suggestions backed by a local workflow file */
+  workflowPromptId?: string;
+  /** Workflow prompt folder for slash suggestions backed by a local workflow file */
+  workflowPromptFolder?: string;
+  /** Workflow prompt metadata for slash suggestions backed by a local workflow file */
+  workflowPrompt?: import('@shared/types/systemManager').WorkflowPromptSummary;
   /** Canonical task id (task suggestions only) */
   taskId?: string;
   /** Owning team name (task suggestions only) */

package/src/renderer/types/tabs.ts

@@ -87,7 +87,9 @@ export interface Tab {
     | 'extensions'
     | 'schedules'
     | 'tasks'
-    | 'graph';
+    | 'graph'
+    | 'chat'
+    | 'society';
 
   /** Session ID (required when type === 'session') */
   sessionId?: string;

package/src/renderer/utils/__tests__/bindProjectSlug.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+
+import { generateBindProject, isValidBindProject } from '../bindProjectSlug';
+
+describe('isValidBindProject', () => {
+  it('accepts lowercase ascii slugs', () => {
+    expect(isValidBindProject('team-1')).toBe(true);
+    expect(isValidBindProject('frontend_bot')).toBe(true);
+    expect(isValidBindProject('a')).toBe(true);
+  });
+
+  it('rejects empty / uppercase / leading hyphen / spaces', () => {
+    expect(isValidBindProject('')).toBe(false);
+    expect(isValidBindProject('Team')).toBe(false);
+    expect(isValidBindProject('-x')).toBe(false);
+    expect(isValidBindProject('has space')).toBe(false);
+  });
+});
+
+describe('generateBindProject', () => {
+  it('returns empty for blank input', () => {
+    expect(generateBindProject('   ', new Set())).toBe('');
+  });
+
+  it('slugifies ascii names', () => {
+    expect(generateBindProject('Front End', new Set())).toMatch(/^front-end-[0-9a-z]+$/);
+  });
+
+  it('falls back to a team- base for non-ascii names', () => {
+    expect(generateBindProject('产品助手', new Set())).toMatch(/^team-[0-9a-z]+$/);
+  });
+
+  it('is deterministic for the same input + existing set (no per-keystroke reshuffle)', () => {
+    const existing = new Set<string>();
+    const a = generateBindProject('产品助手', existing);
+    const b = generateBindProject('产品助手', existing);
+    // The identifier must not reshuffle on every render/keystroke — this is the
+    // root cause of the flickering "already exists" red box.
+    expect(a).toBe(b);
+  });
+
+  it('never collides with existing bind projects (no false "已存在")', () => {
+    // Simulate a prior worker that already took the deterministic id.
+    const taken = generateBindProject('产品助手', new Set());
+    const existing = new Set([taken]);
+    const next = generateBindProject('产品助手', existing);
+    expect(existing.has(next)).toBe(false);
+    expect(isValidBindProject(next)).toBe(true);
+  });
+
+  it('keeps producing non-colliding ids across many creations', () => {
+    const existing = new Set<string>();
+    for (let i = 0; i < 20; i += 1) {
+      const id = generateBindProject('产品助手', existing);
+      expect(existing.has(id)).toBe(false);
+      expect(isValidBindProject(id)).toBe(true);
+      existing.add(id);
+    }
+    expect(existing.size).toBe(20);
+  });
+
+  it('produces a valid identifier for varied inputs', () => {
+    for (const name of ['前端工程师', 'My Cool Bot', '运维-巡检', '']) {
+      const id = generateBindProject(name, new Set());
+      // Empty name is allowed to yield '' (the dialog treats blank as "not set").
+      if (id) expect(isValidBindProject(id)).toBe(true);
+    }
+  });
+});

package/src/renderer/utils/__tests__/groupTransformer.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+
+import { transformChunksToConversation } from '@renderer/utils/groupTransformer';
+import type { EnhancedChunk, ParsedMessage } from '@renderer/types/data';
+import { EMPTY_METRICS } from '@main/types/chunks';
+
+// transformChunksToConversation 是 chunk→会话展示项的核心纯函数（chunk-building
+// 关键路径），此前零覆盖。这里用最小 EnhancedChunk fixture 验证 chunk 类型映射、
+// 计数、顺序、isOngoing 与 compact 阶段编号契约。
+
+const T0 = new Date('2026-06-13T10:00:00.000Z');
+const T1 = new Date('2026-06-13T10:00:01.000Z');
+
+function msg(partial: Partial<ParsedMessage> = {}): ParsedMessage {
+  return {
+    uuid: 'm-1',
+    parentUuid: null,
+    type: 'user',
+    timestamp: T0,
+    content: 'hello',
+    isSidechain: false,
+    isMeta: false,
+    toolCalls: [],
+    toolResults: [],
+    ...partial,
+  } as ParsedMessage;
+}
+
+function base(id: string) {
+  return { id, startTime: T0, endTime: T1, durationMs: 0, metrics: EMPTY_METRICS };
+}
+
+const userChunk = (id: string, content = 'hi') =>
+  ({
+    ...base(id),
+    chunkType: 'user',
+    userMessage: msg({ content }),
+    rawMessages: [],
+  }) as EnhancedChunk;
+
+const aiChunk = (id: string, text = 'ok') =>
+  ({
+    ...base(id),
+    chunkType: 'ai',
+    responses: [msg({ type: 'assistant', content: text })],
+    processes: [],
+    sidechainMessages: [],
+    toolExecutions: [],
+    semanticSteps: [],
+    rawMessages: [],
+  }) as EnhancedChunk;
+
+const systemChunk = (id: string, output = 'done') =>
+  ({
+    ...base(id),
+    chunkType: 'system',
+    message: msg({ content: output }),
+    commandOutput: output,
+    rawMessages: [],
+  }) as EnhancedChunk;
+
+const compactChunk = (id: string) =>
+  ({
+    ...base(id),
+    chunkType: 'compact',
+    message: msg({ content: 'compacted' }),
+    rawMessages: [],
+  }) as EnhancedChunk;
+
+describe('transformChunksToConversation', () => {
+  it('returns an empty conversation for no chunks', () => {
+    const conv = transformChunksToConversation([], []);
+    expect(conv).toEqual({
+      sessionId: '',
+      items: [],
+      totalUserGroups: 0,
+      totalSystemGroups: 0,
+      totalAIGroups: 0,
+      totalCompactGroups: 0,
+    });
+  });
+
+  it('maps each chunk type to the correct item type and counts each once', () => {
+    const conv = transformChunksToConversation(
+      [userChunk('u-1'), aiChunk('u-1'), systemChunk('u-1'), compactChunk('u-1')],
+      []
+    );
+    expect(conv.items.map((i) => i.type)).toEqual(['user', 'ai', 'system', 'compact']);
+    expect(conv.totalUserGroups).toBe(1);
+    expect(conv.totalAIGroups).toBe(1);
+    expect(conv.totalSystemGroups).toBe(1);
+    expect(conv.totalCompactGroups).toBe(1);
+  });
+
+  it('counts are per-type and independent across repeats', () => {
+    const conv = transformChunksToConversation([userChunk('u'), userChunk('u'), aiChunk('u')], []);
+    expect(conv.totalUserGroups).toBe(2);
+    expect(conv.totalAIGroups).toBe(1);
+    expect(conv.totalSystemGroups).toBe(0);
+    expect(conv.totalCompactGroups).toBe(0);
+  });
+
+  it('sessionId comes from the first chunk id', () => {
+    const conv = transformChunksToConversation(
+      [aiChunk('session-42'), userChunk('session-42')],
+      []
+    );
+    expect(conv.sessionId).toBe('session-42');
+  });
+
+  it('preserves chunk order in the flattened items', () => {
+    const conv = transformChunksToConversation(
+      [aiChunk('s'), userChunk('s'), systemChunk('s'), aiChunk('s')],
+      []
+    );
+    expect(conv.items.map((i) => i.type)).toEqual(['ai', 'user', 'system', 'ai']);
+  });
+
+  it('marks only the last AI group as ongoing when isOngoing is true', () => {
+    const conv = transformChunksToConversation(
+      [userChunk('s'), aiChunk('s'), aiChunk('s')],
+      [],
+      true
+    );
+    const aiItems = conv.items.filter((i) => i.type === 'ai');
+    expect(aiItems).toHaveLength(2);
+    const first = aiItems[0].group as { isOngoing?: boolean };
+    const last = aiItems[1].group as { isOngoing?: boolean; status?: string };
+    expect(last.isOngoing).toBe(true);
+    expect(last.status).toBe('in_progress');
+    expect(first.isOngoing).not.toBe(true);
+  });
+
+  it('does not mark any group ongoing when isOngoing is false', () => {
+    const conv = transformChunksToConversation([userChunk('s'), aiChunk('s')], [], false);
+    const aiItem = conv.items.find((i) => i.type === 'ai')!;
+    expect((aiItem.group as { isOngoing?: boolean }).isOngoing).not.toBe(true);
+  });
+
+  it('assigns a compact phase number (>=2) to compact groups', () => {
+    const conv = transformChunksToConversation([userChunk('s'), compactChunk('s')], []);
+    const compactItem = conv.items.find((i) => i.type === 'compact') as
+      | { type: 'compact'; group: { startingPhaseNumber?: number } }
+      | undefined;
+    expect(compactItem).toBeDefined();
+    expect(compactItem!.group.startingPhaseNumber).toBeGreaterThanOrEqual(2);
+  });
+});

package/src/renderer/utils/__tests__/initialRoute.test.ts

@@ -0,0 +1,101 @@
+/**
+ * restoreInitialRoute — maps the URL path to the matching tab action.
+ *
+ * This runs before React's first render (main.tsx) so the store holds the
+ * correct tab on the first paint. These tests pin the path → action mapping
+ * and the idempotent/empty-path behavior.
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import { restoreInitialRoute } from '../initialRoute';
+
+import type { AppState } from '@renderer/store/types';
+
+function mockState(): AppState {
+  return {
+    openTeamTab: vi.fn(),
+    openTeamsTab: vi.fn(),
+    openSystemManager: vi.fn(),
+    openSettingsTab: vi.fn(),
+    openExtensionsTab: vi.fn(),
+    openSchedulesTab: vi.fn(),
+    openTasksTab: vi.fn(),
+    openDashboard: vi.fn(),
+    openSocietyTab: vi.fn(),
+    navigateToSession: vi.fn(),
+    openTab: vi.fn(),
+  } as unknown as AppState;
+}
+
+describe('restoreInitialRoute', () => {
+  it('opens the teams tab for /teams', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/teams');
+    expect(state.openTeamsTab).toHaveBeenCalledTimes(1);
+  });
+
+  it('opens a team tab for /team/:slug', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/team/hermit');
+    expect(state.openTeamTab).toHaveBeenCalledWith('hermit');
+  });
+
+  it('decodes encoded path segments', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/team/%E6%88%91%E7%9A%84%E5%9B%A2%E9%98%9F');
+    expect(state.openTeamTab).toHaveBeenCalledWith('我的团队');
+  });
+
+  it('does nothing for the root path', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/');
+    expect(state.openTeamsTab).not.toHaveBeenCalled();
+    expect(state.openTab).not.toHaveBeenCalled();
+  });
+
+  it('does nothing for an empty path', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '');
+    expect(state.openTab).not.toHaveBeenCalled();
+  });
+
+  it('navigates to a session for /session/:project/:session', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/session/proj-1/sess-9');
+    expect(state.navigateToSession).toHaveBeenCalledWith('proj-1', 'sess-9');
+  });
+
+  it('opens a graph tab for /graph/:team', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/graph/hermit');
+    expect(state.openTab).toHaveBeenCalledWith({
+      type: 'graph',
+      label: 'hermit',
+      teamName: 'hermit',
+    });
+  });
+
+  it('opens a report tab for /report/:project/:session', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/report/proj-1/sess-9');
+    expect(state.openTab).toHaveBeenCalledWith({
+      type: 'report',
+      label: 'Session Report',
+      projectId: 'proj-1',
+      sessionId: 'sess-9',
+    });
+  });
+
+  it('ignores unknown routes', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '/something-unknown');
+    expect(state.openTab).not.toHaveBeenCalled();
+    expect(state.openTeamsTab).not.toHaveBeenCalled();
+  });
+
+  it('trims and ignores leading/trailing slashes', () => {
+    const state = mockState();
+    restoreInitialRoute(state, '///teams///');
+    expect(state.openTeamsTab).toHaveBeenCalledTimes(1);
+  });
+});