aimux-cli 0.1.16 → 0.1.19

package/dist/multiplexer/dashboard-ops.js

@@ -4,6 +4,34 @@ import { graveyardSessionWithFeedback as runGraveyardSessionWithFeedback, resume
 import { isAttachableDashboardSessionEntry, isLiveDashboardServiceRuntimeEntry, } from "../dashboard/runtime-evidence.js";
 import { isDashboardWindowName } from "../tmux/runtime-manager.js";
 import { generateServiceId, serviceLabelForCommand } from "./services.js";
+const dashboardAgentRestoreQueues = new WeakMap();
+const dashboardQueuedAgentRestores = new WeakMap();
+function queuedAgentRestoresFor(host) {
+    let queued = dashboardQueuedAgentRestores.get(host);
+    if (!queued) {
+        queued = new Set();
+        dashboardQueuedAgentRestores.set(host, queued);
+    }
+    return queued;
+}
+async function enqueueDashboardAgentRestore(host, sessionId, work) {
+    const queued = queuedAgentRestoresFor(host);
+    if (queued.has(sessionId))
+        return;
+    queued.add(sessionId);
+    const previous = dashboardAgentRestoreQueues.get(host) ?? Promise.resolve();
+    const current = previous
+        .catch(() => undefined)
+        .then(work)
+        .finally(() => {
+        queued.delete(sessionId);
+        if (dashboardAgentRestoreQueues.get(host) === current) {
+            dashboardAgentRestoreQueues.delete(host);
+        }
+    });
+    dashboardAgentRestoreQueues.set(host, current);
+    await current;
+}
 function buildPendingSessionSeed(input) {
     return {
         index: -1,
@@ -18,22 +46,34 @@ function buildPendingSessionSeed(input) {
         optimistic: true,
     };
 }
+function restoreWarningLines(result) {
+    const warning = typeof result?.warning === "string" ? result.warning.trim() : "";
+    const failures = Array.isArray(result?.teammateFailures)
+        ? result.teammateFailures
+            .map((failure) => {
+            const sessionId = typeof failure?.sessionId === "string" ? failure.sessionId : "";
+            const message = typeof failure?.error === "string"
+                ? failure.error.trim()
+                : typeof failure?.message === "string"
+                    ? failure.message.trim()
+                    : "";
+            if (!sessionId || !message)
+                return "";
+            return message.includes(sessionId) ? message : `${sessionId}: ${message}`;
+        })
+            .filter((line) => line.trim().length > 0)
+        : [];
+    if (failures.length > 0)
+        return Array.from(new Set(failures));
+    if (!warning)
+        return [];
+    return Array.from(new Set([warning, "Stale teammates remain offline; create a new team to replace them."]));
+}
 function assertDashboardMutationSettled(settled, action) {
     if (!settled) {
         throw new Error(`${action} did not settle before timing out`);
     }
 }
-async function waitForRenderedDashboardSessionState(host, sessionId, predicate, timeoutMs = 10_000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        await host.refreshDashboardModelFromService(true);
-        const session = host.getDashboardSessions().find((entry) => entry.id === sessionId);
-        if (predicate(session))
-            return true;
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    return false;
-}
 async function refreshDashboardModelAfterAuthoritativeMutation(host) {
     if (typeof host.refreshDashboardModelFromService === "function") {
         await host.refreshDashboardModelFromService(true);
@@ -165,13 +205,22 @@ async function waitForStableDashboardServiceAbsence(host, serviceId, timeoutMs =
     return false;
 }
 async function runDashboardSessionMutation(host, opts) {
-    host.setPendingDashboardSessionAction(opts.sessionId, opts.pendingAction, { sessionSeed: opts.sessionSeed });
+    const token = host.setPendingDashboardSessionAction(opts.sessionId, opts.pendingAction, {
+        sessionSeed: opts.sessionSeed,
+    });
     opts.onBeforeRequest?.();
     host.renderDashboard();
     try {
         await opts.request();
         assertDashboardMutationSettled(await opts.settle(), opts.pendingAction);
-        host.setPendingDashboardSessionAction(opts.sessionId, null);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearSessionActionIfToken?.(opts.sessionId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else {
+            host.setPendingDashboardSessionAction(opts.sessionId, null);
+        }
         opts.onAfterSettle?.();
         if (opts.successFlash) {
             host.footerFlash = opts.successFlash.message;
@@ -180,19 +229,35 @@ async function runDashboardSessionMutation(host, opts) {
         host.renderDashboard();
     }
     catch (error) {
-        host.setPendingDashboardSessionAction(opts.sessionId, null);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearSessionActionIfToken?.(opts.sessionId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else {
+            host.setPendingDashboardSessionAction(opts.sessionId, null);
+        }
         await opts.onError?.();
         host.showDashboardError(opts.errorTitle, [error instanceof Error ? error.message : String(error)]);
     }
 }
 async function runDashboardServiceMutation(host, opts) {
-    host.setPendingDashboardSessionAction(opts.serviceId, opts.pendingAction, { serviceSeed: opts.serviceSeed });
+    const token = host.setPendingDashboardServiceAction(opts.serviceId, opts.pendingAction, {
+        serviceSeed: opts.serviceSeed,
+    });
     opts.onBeforeRequest?.();
     host.renderDashboard();
     try {
         await opts.request();
         assertDashboardMutationSettled(await opts.settle(), opts.pendingAction);
-        host.setPendingDashboardSessionAction(opts.serviceId, null);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearServiceActionIfToken?.(opts.serviceId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else {
+            host.setPendingDashboardServiceAction(opts.serviceId, null);
+        }
         opts.onAfterSettle?.();
         if (opts.successFlash) {
             host.footerFlash = opts.successFlash.message;
@@ -201,7 +266,14 @@ async function runDashboardServiceMutation(host, opts) {
         host.renderDashboard();
     }
     catch (error) {
-        host.setPendingDashboardSessionAction(opts.serviceId, null);
+        if (typeof token === "number") {
+            if (host.dashboardPendingActions?.clearServiceActionIfToken?.(opts.serviceId, token)) {
+                host.reapplyDashboardPendingActions?.();
+            }
+        }
+        else {
+            host.setPendingDashboardServiceAction(opts.serviceId, null);
+        }
         await opts.onError?.();
         host.showDashboardError(opts.errorTitle, [error instanceof Error ? error.message : String(error)]);
     }
@@ -210,19 +282,18 @@ export async function runDashboardOperation(host, title, lines, work, errorTitle
     return host.dashboardFeedback.runOperation(title, lines, work, errorTitle);
 }
 export async function spawnDashboardAgentWithFeedback(host, input) {
+    const sessionSeed = buildPendingSessionSeed({
+        sessionId: input.sessionId,
+        tool: input.tool,
+        worktreePath: input.worktreePath,
+        pendingAction: "creating",
+    });
     await runDashboardSessionMutation(host, {
         sessionId: input.sessionId,
         pendingAction: "creating",
+        sessionSeed,
         onBeforeRequest: () => {
             host.preferDashboardEntrySelection("session", input.sessionId, input.worktreePath);
-            host.setPendingDashboardSessionAction(input.sessionId, "creating", {
-                sessionSeed: buildPendingSessionSeed({
-                    sessionId: input.sessionId,
-                    tool: input.tool,
-                    worktreePath: input.worktreePath,
-                    pendingAction: "creating",
-                }),
-            });
         },
         request: async () => {
             await host.postToProjectService("/agents/spawn", {
@@ -233,25 +304,24 @@ export async function spawnDashboardAgentWithFeedback(host, input) {
                 open: false,
             }, { timeoutMs: 10_000 });
         },
-        settle: () => waitForRenderedDashboardSessionState(host, input.sessionId, isAttachableDashboardSessionEntry),
+        settle: () => waitForDashboardSessionResumeSettle(host, input.sessionId),
         onError: () => host.refreshDashboardModelFromService(true),
         errorTitle: `Failed to create ${input.tool} agent`,
     });
 }
 export async function forkDashboardAgentWithFeedback(host, input) {
+    const sessionSeed = buildPendingSessionSeed({
+        sessionId: input.targetSessionId,
+        tool: input.tool,
+        worktreePath: input.worktreePath,
+        pendingAction: "forking",
+    });
     await runDashboardSessionMutation(host, {
         sessionId: input.targetSessionId,
         pendingAction: "forking",
+        sessionSeed,
         onBeforeRequest: () => {
             host.preferDashboardEntrySelection("session", input.targetSessionId, input.worktreePath);
-            host.setPendingDashboardSessionAction(input.targetSessionId, "forking", {
-                sessionSeed: buildPendingSessionSeed({
-                    sessionId: input.targetSessionId,
-                    tool: input.tool,
-                    worktreePath: input.worktreePath,
-                    pendingAction: "forking",
-                }),
-            });
         },
         request: async () => {
             await host.postToProjectService("/agents/fork", {
@@ -264,16 +334,36 @@ export async function forkDashboardAgentWithFeedback(host, input) {
                 open: false,
             }, { timeoutMs: 10_000 });
         },
-        settle: () => waitForRenderedDashboardSessionState(host, input.targetSessionId, isAttachableDashboardSessionEntry),
+        settle: () => waitForDashboardSessionResumeSettle(host, input.targetSessionId),
         onError: () => host.refreshDashboardModelFromService(true),
         errorTitle: "Cannot fork session",
     });
 }
 export function setPendingDashboardSessionAction(host, sessionId, kind, opts) {
-    host.dashboardPendingActions.set(sessionId, kind, opts);
+    let token;
+    if (kind) {
+        token = host.dashboardPendingActions.setSessionAction(sessionId, kind, opts);
+    }
+    else {
+        host.dashboardPendingActions.clearSessionAction(sessionId);
+    }
     if (typeof host.reapplyDashboardPendingActions === "function") {
         host.reapplyDashboardPendingActions();
     }
+    return token;
+}
+export function setPendingDashboardServiceAction(host, serviceId, kind, opts) {
+    let token;
+    if (kind) {
+        token = host.dashboardPendingActions.setServiceAction(serviceId, kind, opts);
+    }
+    else {
+        host.dashboardPendingActions.clearServiceAction(serviceId);
+    }
+    if (typeof host.reapplyDashboardPendingActions === "function") {
+        host.reapplyDashboardPendingActions();
+    }
+    return token;
 }
 export async function stopSessionToOfflineWithFeedback(host, session) {
     if (host.mode === "dashboard") {
@@ -417,14 +507,19 @@ export function basenameForHost(value) {
     return basename(value);
 }
 export async function graveyardSessionWithFeedback(host, sessionId, hasWorktrees) {
-    const session = host.offlineSessions.find((s) => s.id === sessionId) ?? host.sessions.find((s) => s.id === sessionId);
+    const dashboardEntry = host.getDashboardSessions?.().find((entry) => entry.id === sessionId);
+    const session = host.offlineSessions.find((s) => s.id === sessionId) ??
+        host.sessions.find((s) => s.id === sessionId) ??
+        dashboardEntry;
     if (host.mode === "dashboard") {
         if (!session)
             return;
         const label = host.getSessionLabel(sessionId) ?? session.label ?? session.command;
+        const sessionSeed = dashboardEntry ?? session;
         await runDashboardSessionMutation(host, {
             sessionId,
             pendingAction: "graveyarding",
+            sessionSeed,
             request: async () => {
                 await host.postToProjectService("/agents/kill", { sessionId }, { timeoutMs: 10_000 });
             },
@@ -441,7 +536,8 @@ export async function graveyardSessionWithFeedback(host, sessionId, hasWorktrees
 export async function resumeOfflineSessionWithFeedback(host, session) {
     if (host.mode === "dashboard") {
         const label = session.label ?? session.command;
-        if (host.dashboardPendingActions.get(session.id) === "starting") {
+        if (host.dashboardPendingActions.getSessionAction(session.id) === "starting" ||
+            queuedAgentRestoresFor(host).has(session.id)) {
             return;
         }
         const sessionSeed = host.getDashboardSessions?.().find((entry) => entry.id === session.id) ??
@@ -453,29 +549,41 @@ export async function resumeOfflineSessionWithFeedback(host, session) {
                 status: "offline",
                 active: false,
                 worktreePath: session.worktreePath,
+                team: session.team,
             };
-        await runDashboardSessionMutation(host, {
-            sessionId: session.id,
-            pendingAction: "starting",
-            sessionSeed,
-            onBeforeRequest: () => {
-                host.footerFlash = `Restoring ${label}`;
-                host.footerFlashTicks = 3;
-            },
-            request: async () => {
-                await host.postToProjectService("/agents/resume", { sessionId: session.id }, { timeoutMs: 10_000 });
-            },
-            settle: () => waitForDashboardSessionResumeSettle(host, session.id),
-            successFlash: { message: `Restored ${label}` },
-            onError: () => host.refreshDashboardModelFromService(true),
-            errorTitle: `Failed to restore "${label}"`,
+        let resumeResult;
+        host.footerFlash = `Queued restore ${label}`;
+        host.footerFlashTicks = 3;
+        host.setPendingDashboardSessionAction(session.id, "starting", { sessionSeed });
+        host.renderDashboard();
+        await enqueueDashboardAgentRestore(host, session.id, async () => {
+            await runDashboardSessionMutation(host, {
+                sessionId: session.id,
+                pendingAction: "starting",
+                sessionSeed,
+                onBeforeRequest: () => {
+                    host.footerFlash = `Restoring ${label}`;
+                    host.footerFlashTicks = 3;
+                },
+                request: async () => {
+                    resumeResult = await host.postToProjectService("/agents/resume", { sessionId: session.id }, { timeoutMs: 60_000 });
+                },
+                settle: () => waitForDashboardSessionResumeSettle(host, session.id),
+                successFlash: { message: `Restored ${label}` },
+                onError: () => host.refreshDashboardModelFromService(true),
+                errorTitle: `Failed to restore "${label}"`,
+            });
         });
+        const warningLines = restoreWarningLines(resumeResult);
+        if (warningLines.length > 0) {
+            host.showDashboardError(`Restored "${label}" with teammate issues`, warningLines);
+        }
         return;
     }
     await runResumeOfflineSessionWithFeedback(dashboardSessionActionDeps(host), session);
 }
 export async function resumeOfflineServiceWithFeedback(host, service) {
-    if (host.dashboardPendingActions.get(service.id) === "starting") {
+    if (host.dashboardPendingActions.getServiceAction(service.id) === "starting") {
         return;
     }
     if (host.mode === "dashboard") {
@@ -505,19 +613,19 @@ export async function resumeOfflineServiceWithFeedback(host, service) {
         });
         return;
     }
-    host.setPendingDashboardSessionAction(service.id, "starting");
+    host.setPendingDashboardServiceAction(service.id, "starting");
     host.footerFlash = `Restoring ${service.label ?? service.id}`;
     host.footerFlashTicks = 3;
     host.renderDashboard();
     try {
         host.resumeOfflineServiceById(service.id);
-        host.setPendingDashboardSessionAction(service.id, null);
+        host.setPendingDashboardServiceAction(service.id, null);
         host.footerFlash = `◆ Started service ${service.label ?? service.id}`;
         host.footerFlashTicks = 3;
         host.renderDashboard();
     }
     catch (error) {
-        host.setPendingDashboardSessionAction(service.id, null);
+        host.setPendingDashboardServiceAction(service.id, null);
         host.refreshLocalDashboardModel();
         host.showDashboardError("Failed to start service", [error instanceof Error ? error.message : String(error)]);
     }
@@ -600,16 +708,22 @@ export async function waitForSessionStartForHost(host, sessionId, timeoutMs = 80
 export function dashboardSessionActionDeps(host) {
     return {
         getSessionLabel: (sessionId) => host.getSessionLabel(sessionId),
-        getPendingAction: (sessionId) => host.dashboardPendingActions.get(sessionId),
+        getPendingAction: (sessionId) => host.dashboardPendingActions.getSessionAction(sessionId),
         setPendingAction: (sessionId, kind) => setPendingDashboardSessionAction(host, sessionId, kind),
-        stopSessionToOffline: (session) => host.stopSessionToOffline(session),
+        stopSessionToOffline: (session) => host.stopAgent(session.id),
         isGraveyardAfterStop: (sessionId) => host.graveyardAfterStopSessionIds.has(sessionId),
         sendAgentToGraveyard: (sessionId) => host.sendAgentToGraveyard(sessionId).then(() => undefined),
-        resumeOfflineSession: (session) => host.mode === "dashboard"
-            ? host
-                .postToProjectService("/agents/resume", { sessionId: session.id }, { timeoutMs: 10_000 })
-                .then(() => undefined)
-            : host.resumeOfflineSession(session),
+        resumeOfflineSession: async (session) => {
+            if (host.mode !== "dashboard") {
+                host.resumeOfflineSession(session);
+                return;
+            }
+            const result = await host.postToProjectService("/agents/resume", { sessionId: session.id }, { timeoutMs: 10_000 });
+            const warningLines = restoreWarningLines(result);
+            if (warningLines.length > 0) {
+                throw new Error(warningLines.join("\n"));
+            }
+        },
         refreshLocalDashboardModel: () => host.refreshLocalDashboardModel(),
         adjustAfterRemove: (hasWorktrees) => host.adjustAfterRemove(hasWorktrees),
         renderDashboard: () => host.renderCurrentDashboardView(),
@@ -622,10 +736,6 @@ export function dashboardSessionActionDeps(host) {
         isSessionRuntimeLive: (session) => host.isSessionRuntimeLive(session),
     };
 }
-export async function takeoverFromDashEntryWithFeedback(host, entry) {
-    const label = entry.label ?? entry.command;
-    await runDashboardOperation(host, `Taking over "${label}"`, [`  Session: ${entry.id}`], () => host.takeoverSessionFromDashEntry(entry), `Failed to take over "${label}"`);
-}
 export async function migrateSessionWithFeedback(host, session, targetPath, targetName) {
     const label = host.getSessionLabel(session.id) ?? session.command;
     if (host.mode !== "dashboard") {
@@ -668,4 +778,3 @@ export async function migrateSessionWithFeedback(host, session, targetPath, targ
         errorTitle: `Failed to migrate "${label}"`,
     });
 }
-//# sourceMappingURL=dashboard-ops.js.map

package/dist/multiplexer/dashboard-state-methods.d.ts

@@ -30,7 +30,7 @@ export declare const dashboardStateMethods: {
         branch: string;
         isBare: boolean;
     }>, mainRepoPath?: string): WorktreeGroup[];
-    applyDashboardModel(this: any, dashSessions: DashboardSession[], dashServices: DashboardService[], worktreeGroups: WorktreeGroup[], mainCheckoutInfo: {
+    applyDashboardModel(this: any, dashSessions: DashboardSession[], dashTeammates: DashboardSession[], dashServices: DashboardService[], worktreeGroups: WorktreeGroup[], mainCheckoutInfo: {
         name: string;
         branch: string;
     }): boolean;
@@ -45,6 +45,7 @@ export declare const dashboardStateMethods: {
     };
     buildDesktopStateSnapshot(this: any): {
         sessions: DashboardSession[];
+        teammates: DashboardSession[];
         services: DashboardService[];
         worktrees: Array<{
             name: string;

package/dist/multiplexer/dashboard-state-methods.js

@@ -36,6 +36,7 @@ export const dashboardStateMethods = {
     },
     loadDashboardUiState() {
         this.dashboardUiStateStore.loadInto(this.dashboardState, this.getDashboardUiClientKey());
+        this.dashboardWorktreeGroupsCache = this.dashboardUiStateStore.orderWorktreeGroups(this.dashboardWorktreeGroupsCache);
     },
     hydrateDashboardScreenState() {
         hydrateDashboardArchiveScreenState(this);
@@ -193,8 +194,8 @@ export const dashboardStateMethods = {
     buildDashboardWorktreeGroups(dashSessions, dashServices, worktrees, mainRepoPath) {
         return buildDashboardWorktreeGroupsImpl(this, dashSessions, dashServices, worktrees, mainRepoPath);
     },
-    applyDashboardModel(dashSessions, dashServices, worktreeGroups, mainCheckoutInfo) {
-        return applyDashboardModelImpl(this, dashSessions, dashServices, worktreeGroups, mainCheckoutInfo);
+    applyDashboardModel(dashSessions, dashTeammates, dashServices, worktreeGroups, mainCheckoutInfo) {
+        return applyDashboardModelImpl(this, dashSessions, dashTeammates, dashServices, worktreeGroups, mainCheckoutInfo);
     },
     invalidateDesktopStateSnapshot() {
         invalidateDesktopStateSnapshotImpl(this);
@@ -224,4 +225,3 @@ export const dashboardStateMethods = {
         await startProjectServicesImpl(this);
     },
 };
-//# sourceMappingURL=dashboard-state-methods.js.map

package/dist/multiplexer/dashboard-tail-methods.d.ts

@@ -1,7 +1,7 @@
 import type { DashboardService, DashboardSession } from "../dashboard/index.js";
 import type { Multiplexer, SessionState } from "./index.js";
 import { dashboardSessionActionDeps as dashboardSessionActionDepsImpl } from "./dashboard-ops.js";
-import type { PendingDashboardActionKind } from "../dashboard/pending-actions.js";
+import type { PendingServiceActionKind, PendingSessionActionKind } from "../pending-actions.js";
 import type { SessionRuntime } from "../session-runtime.js";
 export type DashboardTailMethods = {
     forkAgent(this: Multiplexer, opts: {
@@ -25,6 +25,23 @@ export type DashboardTailMethods = {
     }): Promise<{
         sessionId: string;
     }>;
+    createTeammateAgent(this: Multiplexer, opts: {
+        parentSessionId: string;
+        role?: string;
+        label?: string;
+        toolConfigKey?: string;
+        targetSessionId?: string;
+        targetWorktreePath?: string;
+        open?: boolean;
+        extraArgs?: string[];
+        order?: number;
+    }): Promise<{
+        sessionId: string;
+        parentSessionId: string;
+        teamId: string;
+        role?: string;
+        label?: string;
+    }>;
     renameAgent(this: Multiplexer, sessionId: string, label?: string): Promise<{
         sessionId: string;
         label?: string;
@@ -70,9 +87,12 @@ export type DashboardTailMethods = {
     showMigratePicker(this: Multiplexer, sessionId?: string): void;
     renderMigratePicker(this: Multiplexer): void;
     runDashboardOperation<T>(this: Multiplexer, title: string, lines: string[], work: () => Promise<T> | T, errorTitle?: string): Promise<T | undefined>;
-    setPendingDashboardSessionAction(this: Multiplexer, sessionId: string, kind: PendingDashboardActionKind | null, opts?: {
+    setPendingDashboardSessionAction(this: Multiplexer, sessionId: string, kind: PendingSessionActionKind | null, opts?: {
         sessionSeed?: DashboardSession;
     }): void;
+    setPendingDashboardServiceAction(this: Multiplexer, serviceId: string, kind: PendingServiceActionKind | null, opts?: {
+        serviceSeed?: DashboardService;
+    }): void;
     stopSessionToOfflineWithFeedback(this: Multiplexer, session: SessionRuntime): Promise<void>;
     clearDashboardSubscreens(this: Multiplexer): void;
     renderSessionDetails(this: Multiplexer, session: DashboardSession | undefined, width: number, height: number): string[];
@@ -97,18 +117,10 @@ export type DashboardTailMethods = {
     resumeOfflineSessionWithFeedback(this: Multiplexer, session: SessionState): Promise<void>;
     waitForSessionStart(this: Multiplexer, sessionId: string, timeoutMs?: number): Promise<boolean>;
     dashboardSessionActionDeps(this: Multiplexer): ReturnType<typeof dashboardSessionActionDepsImpl>;
-    takeoverFromDashEntryWithFeedback(this: Multiplexer, entry: DashboardSession): Promise<void>;
     migrateSessionWithFeedback(this: Multiplexer, session: SessionRuntime, targetPath: string, targetName: string): Promise<void>;
     handleMigratePickerKey(this: Multiplexer, data: Buffer): void;
     getDashboardSessions(this: Multiplexer): DashboardSession[];
     getDashboardServices(this: Multiplexer): DashboardService[];
     getDashboardSessionsInVisualOrder(this: Multiplexer): DashboardSession[];
-    takeoverSessionFromDashEntry(this: Multiplexer, entry: DashboardSession): Promise<void>;
-    takeoverSession(this: Multiplexer, target: {
-        id: string;
-        tool: string;
-        backendSessionId: string;
-        fromInstanceId: string;
-    }): Promise<void>;
 };
 export declare const dashboardTailMethods: DashboardTailMethods;