[Init] Initial commit - NetMesh terminal manager

domain/workspaceAiScopeHandoff.ts

@@ -0,0 +1,330 @@
+import { buildAIScopeKey } from './aiSessionsForScope';
+import { resolveInheritedAIActiveSessionId } from './aiWorkspaceScopeInherit';
+
+export type AIActiveSessionIdMap = Readonly<Record<string, string | null | undefined>>;
+
+export type AISessionScopeHandoffLike = {
+  id: string;
+  scope: {
+    type: string;
+    targetId?: string;
+    hostIds?: string[];
+  };
+  updatedAt?: number;
+};
+
+export type AIPanelViewHandoffLike = {
+  mode: 'draft' | 'session';
+  sessionId?: string;
+};
+
+export type SeedWorkspaceAIActiveSessionResult = {
+  activeSessionIdMap: Record<string, string | null>;
+  panelViewByScope: Record<string, AIPanelViewHandoffLike>;
+  panelViewChanged: boolean;
+};
+
+/**
+ * Seed a brand-new workspace scope from member terminal maps (focused first)
+ * so the first paint does not wait on a visible-panel write-back.
+ *
+ * Also materializes an explicit session panel view so follow-up typing does not
+ * fall through to draft-only resolution and create a new chat on send.
+ */
+export function seedWorkspaceAIActiveSessionFromMembers(input: {
+  activeSessionIdMap: AIActiveSessionIdMap;
+  panelViewByScope?: Readonly<Record<string, AIPanelViewHandoffLike | undefined>>;
+  workspaceId: string;
+  memberTerminalIds: readonly string[];
+  preferredTerminalId?: string | null;
+}): SeedWorkspaceAIActiveSessionResult | null {
+  const workspaceKey = buildAIScopeKey('workspace', input.workspaceId);
+  const existing = input.activeSessionIdMap[workspaceKey];
+  if (typeof existing === 'string' && existing.length > 0) {
+    return null;
+  }
+
+  const inherited = resolveInheritedAIActiveSessionId({
+    scopeType: 'workspace',
+    scopeTargetId: input.workspaceId,
+    activeSessionIdMap: input.activeSessionIdMap,
+    memberTerminalIds: input.memberTerminalIds,
+    preferredTerminalId: input.preferredTerminalId,
+  });
+  if (!inherited) return null;
+
+  const previousPanelViewByScope = (
+    input.panelViewByScope as Record<string, AIPanelViewHandoffLike> | undefined
+  ) ?? {};
+  const existingPanelView = previousPanelViewByScope[workspaceKey];
+  const needsPanelView = !(
+    existingPanelView?.mode === 'session'
+    && existingPanelView.sessionId === inherited
+  );
+
+  return {
+    activeSessionIdMap: {
+      ...(input.activeSessionIdMap as Record<string, string | null>),
+      [workspaceKey]: inherited,
+    },
+    panelViewByScope: needsPanelView
+      ? {
+          ...previousPanelViewByScope,
+          [workspaceKey]: { mode: 'session', sessionId: inherited },
+        }
+      : previousPanelViewByScope,
+    panelViewChanged: needsPanelView,
+  };
+}
+
+/**
+ * When a workspace tab dissolves, copy its active chat onto the preferred
+ * surviving terminal before the workspace scope key is pruned. Also remint
+ * workspace-scoped chats and the handed-off active chat when it still lives
+ * under a different terminal (including one that also survives dissolve),
+ * clear that previous terminal selection so ownership filters do not hide the
+ * chat, and seed a session panel view so terminal scopes do not fall back to
+ * a blank draft.
+ */
+export function handoffDissolvedWorkspaceAIScope<T extends AISessionScopeHandoffLike>(input: {
+  activeSessionIdMap: AIActiveSessionIdMap;
+  sessions: readonly T[];
+  workspaceId: string;
+  terminalIds: readonly string[];
+  preferredTerminalId?: string | null;
+  panelViewByScope?: Readonly<Record<string, AIPanelViewHandoffLike | undefined>>;
+}): {
+  activeSessionIdMap: Record<string, string | null>;
+  sessions: T[];
+  panelViewByScope: Record<string, AIPanelViewHandoffLike>;
+  changed: boolean;
+} {
+  const preferredTerminalId = (
+    input.preferredTerminalId
+    && input.terminalIds.includes(input.preferredTerminalId)
+      ? input.preferredTerminalId
+      : input.terminalIds.find(Boolean)
+  ) ?? null;
+
+  const workspaceKey = buildAIScopeKey('workspace', input.workspaceId);
+  const workspaceActive = input.activeSessionIdMap[workspaceKey];
+  const hasWorkspaceActive = typeof workspaceActive === 'string' && workspaceActive.length > 0;
+  const previousPanelViewByScope = (
+    input.panelViewByScope as Record<string, AIPanelViewHandoffLike> | undefined
+  ) ?? {};
+
+  let nextMap: Record<string, string | null> = {
+    ...(input.activeSessionIdMap as Record<string, string | null>),
+  };
+  let mapChanged = false;
+
+  if (preferredTerminalId && hasWorkspaceActive) {
+    const terminalKey = buildAIScopeKey('terminal', preferredTerminalId);
+    let map = nextMap;
+    let changed = false;
+    if (map[terminalKey] !== workspaceActive) {
+      map = { ...map, [terminalKey]: workspaceActive };
+      changed = true;
+    }
+    // Drop duplicate selections so other terminal scopes do not claim this
+    // chat via the activeTerminalSessionIds ownership filter.
+    for (const [key, value] of Object.entries(map)) {
+      if (!key.startsWith('terminal:') || key === terminalKey) continue;
+      if (value !== workspaceActive) continue;
+      if (!changed) {
+        map = { ...map };
+        changed = true;
+      }
+      map[key] = null;
+    }
+    if (changed) {
+      nextMap = map;
+      mapChanged = true;
+    }
+  }
+
+  let sessionsChanged = false;
+  const nextSessions = input.sessions.map((session) => {
+    if (!preferredTerminalId) return session;
+
+    const isWorkspaceScoped = (
+      session.scope.type === 'workspace'
+      && session.scope.targetId === input.workspaceId
+    );
+    // Inherited member chats stay terminal-scoped under the original pane.
+    // Prefer the focused survivor even when that original pane also survives
+    // dissolve, otherwise B's history ownership filter excludes A's chat.
+    const isInheritedActiveChatOnOtherTerminal = (
+      hasWorkspaceActive
+      && session.id === workspaceActive
+      && session.scope.type === 'terminal'
+      && Boolean(session.scope.targetId)
+      && session.scope.targetId !== preferredTerminalId
+    );
+    if (!isWorkspaceScoped && !isInheritedActiveChatOnOtherTerminal) return session;
+    if (session.scope.type === 'terminal' && session.scope.targetId === preferredTerminalId) {
+      return session;
+    }
+
+    sessionsChanged = true;
+    return {
+      ...session,
+      scope: {
+        ...session.scope,
+        type: 'terminal',
+        targetId: preferredTerminalId,
+      },
+      updatedAt: Date.now(),
+    };
+  });
+
+  let panelViewsChanged = false;
+  const nextPanelViewByScope: Record<string, AIPanelViewHandoffLike> = {
+    ...previousPanelViewByScope,
+  };
+  if (preferredTerminalId && hasWorkspaceActive) {
+    const terminalKey = buildAIScopeKey('terminal', preferredTerminalId);
+    const workspacePanelView = previousPanelViewByScope[workspaceKey];
+    const terminalPanelView = previousPanelViewByScope[terminalKey];
+    const nextView: AIPanelViewHandoffLike = (
+      workspacePanelView?.mode === 'session'
+      && workspacePanelView.sessionId === workspaceActive
+    )
+      ? workspacePanelView
+      : { mode: 'session', sessionId: workspaceActive };
+
+    if (
+      terminalPanelView?.mode !== nextView.mode
+      || (nextView.mode === 'session' && terminalPanelView.sessionId !== nextView.sessionId)
+    ) {
+      nextPanelViewByScope[terminalKey] = nextView;
+      panelViewsChanged = true;
+    }
+  }
+
+  if (!mapChanged && !sessionsChanged && !panelViewsChanged) {
+    return {
+      activeSessionIdMap: input.activeSessionIdMap as Record<string, string | null>,
+      sessions: input.sessions as T[],
+      panelViewByScope: previousPanelViewByScope,
+      changed: false,
+    };
+  }
+
+  return {
+    activeSessionIdMap: nextMap,
+    sessions: sessionsChanged ? nextSessions : input.sessions as T[],
+    panelViewByScope: panelViewsChanged ? nextPanelViewByScope : previousPanelViewByScope,
+    changed: true,
+  };
+}
+
+/**
+ * When a still-live workspace loses a member pane whose terminal-scoped chat is
+ * the workspace active selection, remint that chat onto a remaining pane so
+ * member-history matching keeps it visible. Also clear the departed terminal's
+ * active-map entry when it still points at the same chat so detach does not
+ * leave two live scopes driving one agent thread.
+ */
+export function retargetWorkspaceActiveChatAfterMemberLoss<T extends AISessionScopeHandoffLike>(input: {
+  activeSessionIdMap: AIActiveSessionIdMap;
+  sessions: readonly T[];
+  workspaceId: string;
+  previousMemberTerminalIds: readonly string[];
+  currentMemberTerminalIds: readonly string[];
+  preferredTerminalId?: string | null;
+}): {
+  activeSessionIdMap: Record<string, string | null>;
+  sessions: T[];
+  changed: boolean;
+} {
+  const previousMap = input.activeSessionIdMap as Record<string, string | null>;
+  const workspaceKey = buildAIScopeKey('workspace', input.workspaceId);
+  const workspaceActive = previousMap[workspaceKey];
+  const survivorTerminalIds = new Set(input.currentMemberTerminalIds.filter(Boolean));
+  const departedTerminalIds = input.previousMemberTerminalIds.filter(
+    (sessionId) => sessionId && !survivorTerminalIds.has(sessionId),
+  );
+
+  let nextMap: Record<string, string | null> = { ...previousMap };
+  let mapChanged = false;
+  if (typeof workspaceActive === 'string' && workspaceActive.length > 0) {
+    for (const departedTerminalId of departedTerminalIds) {
+      const departedKey = buildAIScopeKey('terminal', departedTerminalId);
+      if (nextMap[departedKey] !== workspaceActive) continue;
+      nextMap = { ...nextMap, [departedKey]: null };
+      mapChanged = true;
+    }
+  }
+
+  if (typeof workspaceActive !== 'string' || workspaceActive.length === 0) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+
+  if (survivorTerminalIds.size === 0) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+
+  const preferredTerminalId = (
+    input.preferredTerminalId
+    && survivorTerminalIds.has(input.preferredTerminalId)
+      ? input.preferredTerminalId
+      : input.currentMemberTerminalIds.find((id) => survivorTerminalIds.has(id))
+  ) ?? null;
+  if (!preferredTerminalId) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+
+  const activeSession = input.sessions.find((session) => session.id === workspaceActive);
+  if (!activeSession) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+  if (activeSession.scope.type !== 'terminal' || !activeSession.scope.targetId) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+  if (survivorTerminalIds.has(activeSession.scope.targetId)) {
+    return {
+      activeSessionIdMap: mapChanged ? nextMap : previousMap,
+      sessions: input.sessions as T[],
+      changed: mapChanged,
+    };
+  }
+
+  return {
+    activeSessionIdMap: mapChanged ? nextMap : previousMap,
+    sessions: input.sessions.map((session) => (
+      session.id !== workspaceActive
+        ? session
+        : {
+            ...session,
+            scope: {
+              ...session.scope,
+              type: 'terminal',
+              targetId: preferredTerminalId,
+            },
+            updatedAt: Date.now(),
+          }
+    )),
+    changed: true,
+  };
+}