@qilin-agent/client-ui-workspace 0.0.0-stage → 3.1.3

package/lib/types/client/navigation.d.ts

@@ -0,0 +1,193 @@
+/** Workspace archive and directory UI capability. */
+import { Service, type Context } from '@qilin-agent/kylin';
+import type { ClientRemote, DirectoryListing, RemoteFailure, RemoteResult } from '@qilin-agent/api-remotes/client';
+import type { ISessions, SessionTarget } from '@qilin-agent/api-session-controller/client';
+import { type ObservableSnapshot } from '@qilin-agent/client-store';
+import type { SubagentAddress } from '@qilin-agent/subagent/client';
+import type { IWorkspaces, WorkspaceId } from '@qilin-agent/api-workspace-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { Workbench } from '@qilin-agent/client-ui-workbench/client';
+import type { WorkspaceViewStoreActions } from './stores.ts';
+/** The main-pane selection a navigation action publishes: one Session, or one direct-parent subagent address. */
+export interface MainSelection {
+    readonly sessionId?: SessionId;
+    readonly subagentAddress?: SubagentAddress;
+}
+/** Workspace archive and directory operations consumed by Client UI domains. */
+export interface UiWorkspace {
+    /**
+     * The persisted main-pane selection. The Session Controller owns the catalog and
+     * leaves view selection to navigation, so surfaces that need "the Session the
+     * shell is showing" read it here.
+     */
+    readonly selection: ObservableSnapshot<MainSelection>;
+    /**
+     * Select a Session and show its Conversation as one UI navigation action.
+     * @param target - known Session identity or durable direct-parent subagent address to display.
+     */
+    openSession(target: SessionTarget): void;
+    /**
+     * Connect a Workspace and open its Session unless a later navigation supersedes it.
+     * @param workspaceId - target Workspace.
+     * @param beforeOpen - optional synchronous preparation for the selected Session,
+     * skipped after supersession; a throw aborts the open and releases the retained reference.
+     * @returns completion; a superseded request may create a Session but does not open it.
+     */
+    openWorkspace(workspaceId: WorkspaceId, beforeOpen?: (sessionId: SessionId) => void): Promise<void>;
+    /**
+     * Fork a Session and open the child unless a later navigation supersedes it.
+     * @param sessionId - source Session.
+     * @returns completion; a superseded request leaves its child available without selecting it.
+     */
+    forkSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Resolve the reusable or newly created blank Session for a Workspace.
+     * @param workspaceId - target Workspace.
+     * @returns a Session already addressable through the Session Controller.
+     */
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    /**
+     * Start a New Session flow and navigate to its Session.
+     * @param workspaceId - explicit target; absent inherits the current or most recent Workspace.
+     */
+    startSession(workspaceId?: WorkspaceId): void;
+    /**
+     * Switch the current blank Session to an explicitly picked new-task preset
+     * (the hero chip's per-tag choice; the next new task already names it at
+     * create). A started or absent Session keeps its composition.
+     * @param presetId - the picked preset id.
+     */
+    adoptBlankSessionPreset(presetId: string): void;
+    /**
+     * Archive a Session and clear it when it is the current selection.
+     * @param sessionId - Session to archive.
+     */
+    archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Unarchive a Session, restoring it to its recorded Workspace position.
+     * @param sessionId - Session to unarchive.
+     */
+    unarchiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Pin a Session on the Host and front its saved position in every account that owns it.
+     * @param sessionId - Session to pin.
+     */
+    pinSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Unpin a Session on the Host; saved positions stay as they are.
+     * @param sessionId - Session to unpin.
+     */
+    unpinSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Open the Host-native directory picker.
+     * @returns the selected directory, or null when cancelled.
+     */
+    pickDirectory(): Promise<string | null>;
+    /**
+     * List one Host directory level.
+     * @param path - directory path; absent selects the Host home.
+     * @param signal - cancellation for a superseded scan.
+     * @returns directory entries and breadcrumb ancestry.
+     */
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    /**
+     * Create a child directory.
+     * @param path - existing parent directory.
+     * @param name - child directory name.
+     * @returns created absolute path.
+     */
+    createDirectory(path: string, name: string): Promise<string>;
+}
+declare module '@qilin-agent/kylin' {
+    interface Context {
+        /** Cross-Controller Workspace navigation and directory UI capability. */
+        uiWorkspace: UiWorkspace;
+    }
+}
+/** Structured directory failure exposed to directory UI consumers. */
+export declare class DirectoryBrowseError extends Error {
+    readonly rpcError: RemoteFailure;
+    readonly name = "DirectoryBrowseError";
+    /** @param rpcError - Host directory business failure. */
+    constructor(rpcError: RemoteFailure);
+}
+/**
+ * The preset-switch caller the browsing region consumes: the one Remote method
+ * the blank-session tag rebind needs, stated structurally so consumers pass the
+ * live namespace or a test double without a cast.
+ */
+export interface AgentPresetSwitcher {
+    /**
+     * Switch one blank session's agent composition to a preset.
+     * @param id - the blank session to recompose.
+     * @param agentPreset - the preset id to compose from.
+     * @returns the recorded preset id, or a failure (`agent-preset/locked` once
+     * the session has started).
+     */
+    select(id: SessionId, agentPreset: string): Promise<RemoteResult<string>>;
+}
+/** Implements Workspace archive and directory UI operations. */
+declare class UiWorkspaceService extends Service implements UiWorkspace {
+    private readonly directoryPicker;
+    private readonly agentPresets;
+    private readonly workbench;
+    private readonly workspaces;
+    private readonly sessions;
+    private readonly view;
+    private readonly connecting;
+    private readonly lifetime;
+    /**
+     * The persisted main-pane selection. Published as the `mainSelection` root
+     * standard source, because the Session Controller owns the catalog and leaves
+     * view selection to navigation.
+     */
+    readonly selection: import("@qilin-agent/client-store").SnapshotStore<MainSelection>;
+    private mainReference;
+    /**
+     * @param ctx - Client root Context.
+     * @param directoryPicker - the directory-picking Remote namespace.
+     * @param agentPresets - the preset-switch caller, for the blank-session
+     * tag rebind (D3: a blank session may switch presets; a started one may not).
+     * @param workbench - the tag state owner, supplying each new task's preset
+     * and the visibility fold the reuse rule checks.
+     * @param workspaces - pure Workspace Controller.
+     * @param sessions - pure Session Controller.
+     * @param view - the browser's viewing-store write set, which owns saved Session order.
+     */
+    constructor(ctx: Context, directoryPicker: ClientRemote['directoryPicker'], agentPresets: AgentPresetSwitcher, workbench: Workbench, workspaces: IWorkspaces, sessions: ISessions, view: Pick<WorkspaceViewStoreActions, 'pinSessionOrder'>);
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    /**
+     * Rebind every blank session of the current Workspace to the now-active
+     * tag's preset. Blank sessions carried over from the other tag would
+     * otherwise sit hidden in this tag's filtered list; a non-blank session
+     * stays exactly as it is (the Host refuses non-blank switches anyway).
+     */
+    rebindBlanksAfterTagSwitch(): void;
+    /**
+     * Switch one blank session to the active tag's preset when the preset it
+     * was created under does not show under this tag. Fire-and-forget: the
+     * session stays usable either way, and a `locked` verdict means it engaged
+     * mid-rebind, so its own preset stands.
+     * @param id - the blank session to align.
+     */
+    private rebindBlankToActiveTag;
+    adoptBlankSessionPreset(presetId: string): void;
+    openSession(target: SessionTarget): void;
+    openWorkspace(workspaceId: WorkspaceId, beforeOpen?: (sessionId: SessionId) => void): Promise<void>;
+    forkSession(sessionId: SessionId): Promise<void>;
+    startSession(workspaceId?: WorkspaceId): void;
+    archiveSession(sessionId: SessionId): Promise<void>;
+    unarchiveSession(sessionId: SessionId): Promise<void>;
+    pinSession(sessionId: SessionId): Promise<void>;
+    unpinSession(sessionId: SessionId): Promise<void>;
+    pickDirectory(): Promise<string | null>;
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    createDirectory(path: string, name: string): Promise<string>;
+    private watchNavigation;
+    /** @returns true when an archived current selection was cleared. */
+    private clearArchivedCurrent;
+    private clearMain;
+    private replaceMain;
+}
+export { UiWorkspaceService };
+//# sourceMappingURL=navigation.d.ts.map

package/lib/types/client/pin-order.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The account memberships a pin order write reconciles against, derived from
+ * the same Host snapshots the browser orders by, so the UiWorkspace service
+ * completes the write without the browser in the loop.
+ */
+import type { SessionListState } from '@qilin-agent/api-session-controller/client';
+import type { WorkspaceView } from '@qilin-agent/api-workspace-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+/**
+ * Every account's complete membership: each Workspace, Ungrouped, and the flat list.
+ * @param workspaces - current Host Workspaces.
+ * @param list - current Session list snapshot.
+ * @returns membership per account key plus the summaries a reconciliation orders by.
+ */
+export declare function pinOrderSource(workspaces: readonly WorkspaceView[], list: SessionListState): {
+    members: Readonly<Record<string, readonly SessionId[]>>;
+    summaries: SessionListState['byId'];
+};
+/**
+ * The accounts a pinned Session leads: its group (or Ungrouped) and the flat list.
+ * @param workspaces - current Host Workspaces.
+ * @param sessionId - the Session being pinned.
+ * @returns the account keys a pin write fronts.
+ */
+export declare function pinOrderAccounts(workspaces: readonly WorkspaceView[], sessionId: SessionId): readonly string[];
+//# sourceMappingURL=pin-order.d.ts.map

package/lib/types/client/rows/Rows.d.ts

@@ -0,0 +1,116 @@
+import type { PropsRenderSlots } from '@qilin-agent/client-ui-slots';
+import type { WorkspaceBrowserProps } from '../contract/slots.ts';
+import type { GroupNode, SearchResultNode, SessionNode } from '../tree.ts';
+/** The standard locale seat, prop-passed from the browser root. */
+type RowTranslate = WorkspaceBrowserProps['t'];
+/**
+ * Row drag wiring supplied by the tree owner. `drop` reports the half of the
+ * row where the pointer released so the owner can resolve an insert anchor.
+ */
+export interface RowDragProps {
+    /** Start dragging this row. */
+    start: () => void;
+    /** A compatible row drag is in flight. */
+    active: boolean;
+    /** Current marker on this row: insert line above, below, or none. */
+    marker: 'before' | 'after' | null;
+    /** Report the hovered half while a compatible drag passes over this row. */
+    hover: (half: 'before' | 'after') => void;
+    drop: (half: 'before' | 'after') => void;
+    end: () => void;
+}
+/** Drag lifecycle owned by a workspace row; its enclosing group owns hit testing. */
+interface WorkspaceRowDragProps {
+    start: () => void;
+    end: () => void;
+}
+/**
+ * Project (workspace) header row: folder + title;
+ * hover reveals the chevron and create button, and dwelling on a real
+ * Workspace shows its hover card (the ungrouped bucket has none).
+ * `containsCurrent` arrives on the node (derivation fact, no renderer scan).
+ * @param props.group - derived group node.
+ * @param props.containsCurrentDescendant - highlight an ancestor even when its subtree is collapsed.
+ * @param props.onToggle - expand/collapse the group.
+ * @param props.onCreate - start a frontend Session inside this Workspace.
+ * @param props.drag - optional workspace-row drag wiring.
+ * @param props.home - host account home for POSIX hover-path abbreviation.
+ * @param props.t - the browser root's locale seat.
+ * @returns the row element.
+ */
+export declare function ProjectRowItem({ group, containsCurrentDescendant, onToggle, onCreate, actions, drag, home, t }: {
+    group: GroupNode;
+    containsCurrentDescendant?: boolean;
+    onToggle: () => void;
+    onCreate: () => void;
+    /** Real-Workspace actions; absent for the ungrouped bucket (no menu shown). */
+    actions?: {
+        rename: () => void;
+        delete: () => void;
+    } | undefined;
+    /** Present only for real Workspace rows in the grouped view. */
+    drag?: WorkspaceRowDragProps | undefined;
+    /** Host account home; POSIX home-rooted hover paths display as `~`. */
+    home?: string | undefined;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+/** Child seats a Session row renders: its leading decoration and hover-card section. */
+type SessionRowRenderSlots = PropsRenderSlots<'sidebar.session.row.leading' | 'sidebar.session.row.hover'>['renderSlot'];
+/**
+ * One flat search result: title, Workspace context, and optional content
+ * excerpt. Search navigation opens the session only; it does not address an
+ * event inside the conversation.
+ * @param props.result - merged local/content search row.
+ * @param props.currentId - selected session id.
+ * @param props.onOpen - open the selected session.
+ * @param props.t - Workspace-browser translation seat.
+ * @returns the result button.
+ */
+export declare function SearchResultItem({ result, currentId, onOpen, t }: {
+    result: SearchResultNode;
+    currentId: string | undefined;
+    onOpen: (id: SearchResultNode['id']) => void;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+/**
+ * One top-level 34px session row: status dot (pending user interaction outranks
+ * own or descendant activity), title, relative time, and the row actions menu.
+ * @param props.node - derived session node.
+ * @param props.currentId - selected session id (row highlight).
+ * @param props.now - epoch ms for relative-time formatting.
+ * @param props.onOpen - open a session by id.
+ * @param props.onRename - open the session rename dialog (id + current title).
+ * @param props.onFork - fork a session at its last completed turn.
+ * @param props.onArchive - archive a session by id.
+ * @param props.onPin - pin a session by id (leading its group and the flat list).
+ * @param props.onUnpin - drop a session's pin.
+ * @param props.onReveal - scroll this row into view after search navigation, then acknowledge it.
+ * @param props.drag - optional row-drag target wiring; blank rows cannot start a drag.
+ * @param props.t - the browser root's locale seat.
+ * @returns the session row.
+ */
+export declare function SessionNodeItem({ node, currentId, now, onOpen, onRename, onFork, onArchive, onPin, onUnpin, onReveal, drag, renderSlot, t, }: {
+    node: SessionNode;
+    currentId: string | undefined;
+    now: number;
+    onOpen: (id: SessionNode['id']) => void;
+    /** Open the browser-owned session rename dialog (row menu action). */
+    onRename: (id: SessionNode['id'], currentTitle: string) => void;
+    /** Fork a session at its last completed turn (row menu action). */
+    onFork: (id: SessionNode['id']) => void;
+    /** Archive this session (row menu action; commits without a dialog). */
+    onArchive: (id: SessionNode['id']) => void;
+    /** Pin this session ahead of unpinned rows (row menu and hover action). */
+    onPin: (id: SessionNode['id']) => void;
+    /** Drop this session's pin (row menu and hover action). */
+    onUnpin: (id: SessionNode['id']) => void;
+    /** Scroll this row into view after search navigation, then acknowledge it. */
+    onReveal?: (() => void) | undefined;
+    /** Present on reorderable-list rows so every row can remain a drop target. */
+    drag?: RowDragProps | undefined;
+    /** Child-seat renderer for the row's leading decoration and hover-card section. */
+    renderSlot: SessionRowRenderSlots;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=Rows.d.ts.map

package/lib/types/client/rows/WorkbenchSwitch.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The dual-workbench switch: the active tag renders as an outlined pill with
+ * icon and label, the inactive tag collapses to an icon-only button. Visual
+ * order is constant (coding left, general right); the pill and icon roles
+ * swap with the active tag.
+ */
+import type { ReactNode } from 'react';
+import type { WorkbenchTag } from '@qilin-agent/client-ui-workbench/client';
+/**
+ * Render the two-tag switch. Both tags stay mounted and reachable — only the
+ * label of the inactive one is hidden — so the tab semantics of the previous
+ * segmented control carry over: roving tab stop on the selected tag,
+ * Left/Right to move selection.
+ * @param props.value - the active tag.
+ * @param props.onChange - selection requested by click or Left/Right.
+ * @param props.labels - localized tag names, keyed by tag; the inactive
+ * button's accessible name (its label is hidden).
+ * @param props.ariaLabel - localized accessible name for the tab list.
+ * @param props.panelId - DOM id of the panel the tabs control.
+ * @returns the tab list, without its panel.
+ */
+export declare function WorkbenchSwitch({ value, onChange, labels, ariaLabel, panelId }: {
+    value: WorkbenchTag;
+    onChange: (tag: WorkbenchTag) => void;
+    labels: Readonly<Record<WorkbenchTag, string>>;
+    ariaLabel: string;
+    panelId: string;
+}): ReactNode;
+//# sourceMappingURL=WorkbenchSwitch.d.ts.map

package/lib/types/client/rows/WorkspaceBrowser.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceBrowserProps } from '../contract/slots.ts';
+/**
+ * Render the browsing region.
+ * @param props - composed slot props (shell owner share + store + injected actions).
+ * @returns the region element tree.
+ */
+export declare function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionStatus, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, pinSession, unpinSession, createWorkspace, searchSessions, searchResultLimit, requestSearch, requestAddWorkspace, closeAddWorkspace, closeRenameRequest, setDirectoryBusy, useDirectoryFlow, useHostInfo, useWorkspaceShortcuts, useShortcuts, renderSlot, t, }: WorkspaceBrowserProps): import("react").JSX.Element;
+//# sourceMappingURL=WorkspaceBrowser.d.ts.map

package/lib/types/client/shortcuts.d.ts

@@ -0,0 +1,39 @@
+/** Workspace command registration and browser-owned opening requests. */
+import type { Context } from '@qilin-agent/kylin';
+import { type SnapshotStore } from '@qilin-agent/client-store';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { UiWorkspace } from './navigation.ts';
+/** Transient requests consumed by the existing workspace browser. */
+export interface WorkspaceShortcutState {
+    readonly searchRequest: number;
+    readonly addRequested: boolean;
+    readonly directoryBusy: boolean;
+    readonly renameTarget: {
+        readonly sessionId: SessionId;
+        readonly currentTitle: string;
+    } | null;
+}
+interface WorkspaceShortcutControls {
+    state: SnapshotStore<WorkspaceShortcutState>;
+    search: () => void;
+    add: () => void;
+    closeAdd: () => void;
+    directoryBusy: (busy: boolean) => void;
+    rename: (sessionId: SessionId, currentTitle: string) => void;
+    closeRename: () => void;
+}
+/**
+ * Create the private browser request source shared by commands and controls.
+ * @returns observable state and its complete mutation callbacks.
+ */
+export declare function createWorkspaceShortcutControls(): WorkspaceShortcutControls;
+/**
+ * Register navigation commands against the existing workspace owner.
+ * @param ctx - plugin context with the shortcut, locale, and model services.
+ * @param navigation - session creation and forking from the pointer controls' navigation service.
+ * @param controls - browser-owned opening requests.
+ * @param archiveSession - shared archive action, including running-work confirmation and notices.
+ */
+export declare function installWorkspaceShortcuts(ctx: Context, navigation: Pick<UiWorkspace, 'startSession' | 'forkSession'>, controls: ReturnType<typeof createWorkspaceShortcutControls>, archiveSession: (sessionId: SessionId) => void): void;
+export {};
+//# sourceMappingURL=shortcuts.d.ts.map

package/lib/types/client/stores.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The workspace browser's viewing store: the session-list grouping mode,
+ * persisted across reloads. Module level exports the factory only (a
+ * module-level handle would pin the store identity across plugin reloads);
+ * register() receives the factory and the browser derives its PropsStore
+ * share from the return type.
+ */
+import { type EngineStoreHandle } from '@qilin-agent/client-store';
+import type { SessionListState } from '@qilin-agent/api-session-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+/** Browser-local order account for the hierarchy-free flat Session list. */
+export declare const FLAT_SESSION_ORDER_KEY = "__flat_session_order__";
+/** Session-list grouping mode: sibling Workspace sections, a Workspace tree, or one flat list. */
+export type SessionGroupBy = 'workspace' | 'workspace-tree' | 'flat';
+/** Session order: saved manual positions or current recency. */
+export type SessionOrderBy = 'manual' | 'updated';
+/** Workspace browser viewing state persisted across surface remounts and reloads. */
+type WorkspaceViewState = {
+    groupBy: SessionGroupBy;
+    orderBy: SessionOrderBy;
+    /** Explicit group expansion keyed by Workspace identity, including descendants in tree mode. */
+    groupExpansion: Record<string, boolean>;
+    /** Saved manual order per Workspace group plus the browser-local flat-list account. */
+    sessionOrderByAccount: Record<string, string[]>;
+};
+/** What a pin order write reconciles a pinned Session's accounts against. */
+export interface PinOrderSource {
+    /** Every account's complete membership: each Workspace, Ungrouped, and the flat list. */
+    members: Readonly<Record<string, readonly SessionId[]>>;
+    /** Session summaries the reconciliation orders new members by. */
+    summaries: SessionListState['byId'];
+}
+/**
+ * Annotation twin of the actions literal below (the export needs a declared
+ * return type); drift fails assignability at the defineStore call.
+ */
+type WorkspaceViewActions = {
+    setGroupBy: (draft: WorkspaceViewState, mode: SessionGroupBy) => void;
+    setOrderBy: (draft: WorkspaceViewState, mode: SessionOrderBy, initialOrders: Readonly<Record<string, readonly string[]>>) => void;
+    setGroupExpanded: (draft: WorkspaceViewState, key: string, expanded: boolean) => void;
+    retainAccountKeys: (draft: WorkspaceViewState, workspaceKeys: readonly string[]) => void;
+    syncSessionOrders: (draft: WorkspaceViewState, orders: Readonly<Record<string, readonly string[]>>) => void;
+    setSessionOrder: (draft: WorkspaceViewState, accountKey: string, order: readonly string[], initialOrders: Readonly<Record<string, readonly string[]>>) => void;
+    pinSessionOrder: (draft: WorkspaceViewState, sessionId: SessionId, accountKeys: readonly string[], source: PinOrderSource) => void;
+};
+/** The bound write set of one viewing-store instance (what the UiWorkspace service drives). */
+export type WorkspaceViewStoreActions = ReturnType<ReturnType<typeof createWorkspaceViewStore>['create']>['actions'];
+/**
+ * Create the workspace browser viewing store handle.
+ * @returns the store handle (spec + type + identity + factory in one).
+ */
+export declare function createWorkspaceViewStore(): EngineStoreHandle<WorkspaceViewState, WorkspaceViewActions>;
+export {};
+//# sourceMappingURL=stores.d.ts.map

package/lib/types/client/subagent-lineage.d.ts

@@ -0,0 +1,21 @@
+/** UI Workspace-owned projection of descendant counts from Session summaries. */
+import type { SessionId } from '@qilin-agent/session/types';
+interface LineageEntry {
+    readonly id: SessionId;
+    readonly parentId?: SessionId;
+    readonly origin?: 'subagent';
+    readonly running: boolean;
+}
+/** Descendant counts for one possible parent Session. */
+export interface SubagentDescendantSummary {
+    readonly count: number;
+    readonly runningCount: number;
+}
+/**
+ * Index uninterrupted subagent descendants under each ancestor.
+ * @param summaries - Session summaries keyed by id.
+ * @returns descendant totals keyed by possible parent id.
+ */
+export declare function indexSubagentDescendants(summaries: Readonly<Record<SessionId, LineageEntry>>): ReadonlyMap<SessionId, SubagentDescendantSummary>;
+export {};
+//# sourceMappingURL=subagent-lineage.d.ts.map