aimux-cli 0.1.15 → 0.1.18

package/dist/multiplexer/persistence-methods.js

@@ -1,18 +1,21 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { basename, join } from "node:path";
-import { debug } from "../debug.js";
-import { DashboardPendingActions } from "../dashboard/pending-actions.js";
 import { addDashboardOperationFailure, clearDashboardOperationFailures, listDashboardOperationFailures, } from "../dashboard/operation-failures.js";
 import { composeDashboardWorktreeGroups } from "./dashboard-model.js";
 import { loadDaemonInfo } from "../daemon.js";
-import { getGraveyardPath, getLocalAimuxDir, getProjectStateDir, getStatePath } from "../paths.js";
+import { getProjectStateDir, getStatePath } from "../paths.js";
 import { loadMetadataState } from "../metadata-store.js";
-import { renderCurrentDashboardView as renderCurrentDashboardViewImpl, stopSessionToOffline } from "./runtime-state.js";
-import { listWorktreeGraveyardEntries as listWorktreeGraveyardEntriesImpl, listWorktreeGraveyardPaths, writeWorktreeGraveyardEntries, } from "./worktree-graveyard.js";
+import { createRuntimeExchangeStore } from "../runtime-core/exchange-store.js";
+import { renderCurrentDashboardView as renderCurrentDashboardViewImpl } from "./runtime-state.js";
+import { listWorktreeGraveyardEntries as listWorktreeGraveyardEntriesImpl, listWorktreeGraveyardPaths, } from "./worktree-graveyard.js";
 import { loadStatusline, renderTmuxStatuslineFromData } from "../tmux/statusline.js";
 import { ensureTmuxStatuslineDir, invalidateTmuxStatuslineArtifacts } from "../tmux/statusline-cache.js";
 import { markLastUsed } from "../last-used.js";
+import { isTeammateSession } from "../team.js";
+import { listTopologySessionStates, removeTopologySessionsForWorktree, resurrectTopologySession, } from "../runtime-core/topology-sessions.js";
+import { removeTopologyServicesForWorktree, upsertTopologyService } from "../runtime-core/topology-services.js";
+import { deleteTopologyWorktreeGraveyardEntry, listTopologyWorktreeGraveyard, moveTopologyWorktreeToGraveyard, removeTopologyWorktree, resurrectTopologyWorktreeFromGraveyard, upsertTopologyWorktree, } from "../runtime-core/topology-worktrees.js";
 import { findMainRepo, getWorktreeBaseDir, getWorktreeAddArgs, getWorktreeCreatePath, isToolInternalWorktree, listWorktrees as listAllWorktrees, } from "../worktree.js";
 function recordDashboardFailure(host, input) {
     const failure = addDashboardOperationFailure(input);
@@ -25,21 +28,37 @@ function recordDashboardFailure(host, input) {
     });
     return failure;
 }
+function refreshDashboardWorktreeProjection(host) {
+    host.invalidateDesktopStateSnapshot();
+    host.refreshLocalDashboardModel();
+    host.metadataServer?.notifyChange?.();
+    if (host.mode === "dashboard") {
+        host.renderDashboard();
+    }
+}
+function orderStatuslineItemsByWorktree(items, orderForWorktree) {
+    const grouped = new Map();
+    for (const item of items) {
+        const key = item.worktreePath ?? "__main__";
+        const group = grouped.get(key) ?? { worktreePath: item.worktreePath, items: [] };
+        group.items.push(item);
+        grouped.set(key, group);
+    }
+    return [...grouped.values()].flatMap((group) => orderForWorktree(group.items, group.worktreePath));
+}
+function exchangeTaskCounts() {
+    try {
+        const exchange = createRuntimeExchangeStore().read();
+        return {
+            pending: exchange.tasks.filter((task) => task.status === "pending").length,
+            assigned: exchange.tasks.filter((task) => task.status === "assigned" || task.status === "in_progress" || task.status === "blocked").length,
+        };
+    }
+    catch {
+        return { pending: 0, assigned: 0 };
+    }
+}
 export const persistenceMethods = {
-    writeSessionsFile() {
-        const dir = getLocalAimuxDir();
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        const localSessions = this.sessions.map((s) => ({
-            id: s.id,
-            tool: s.command,
-            createdAt: s.startTime ? new Date(s.startTime).toISOString() : undefined,
-            backendSessionId: s.backendSessionId,
-            worktreePath: this.sessionWorktreePaths.get(s.id),
-        }));
-        const data = this.instanceDirectory.buildSessionsFileEntries(localSessions, this.instanceDirectory.getRemoteInstancesSafe(this.instanceId, process.cwd()));
-        writeFileSync(`${dir}/sessions.json`, JSON.stringify(data, null, 2) + "\n");
-    },
     writeStatuslineFile(input) {
         try {
             if (this.mode !== "project-service")
@@ -48,6 +67,7 @@ export const persistenceMethods = {
             for (const session of this.sessions) {
                 this.syncTmuxWindowMetadata(session.id);
             }
+            this.dashboardUiStateStore.loadSharedState(this.dashboardState);
             this.refreshDesktopStateSnapshot();
             const dir = getProjectStateDir();
             const filePath = join(dir, "statusline.json");
@@ -115,7 +135,7 @@ export const persistenceMethods = {
         });
         this.writeStatuslineTextFile("top-dashboard.txt", dashboardTop);
         this.writeStatuslineTextFile("bottom-dashboard.txt", dashboardBottom);
-        for (const entry of data.sessions) {
+        for (const entry of [...data.sessions, ...(data.teammates ?? [])]) {
             if (!entry.tmuxWindowId)
                 continue;
             const renderOptions = {
@@ -139,7 +159,7 @@ export const persistenceMethods = {
             project: basename(process.cwd()),
             sessions: [],
             metadata: {},
-            tasks: { pending: 0, assigned: 0 },
+            tasks: exchangeTaskCounts(),
             controlPlane: { daemonAlive: true, projectServiceAlive: false },
             flash: null,
             updatedAt: new Date().toISOString(),
@@ -154,11 +174,17 @@ export const persistenceMethods = {
     },
     buildStatuslineSnapshot() {
         const desktopState = this.desktopStateSnapshot ?? this.buildDesktopStateSnapshot();
+        const orderedSessions = orderStatuslineItemsByWorktree(desktopState.sessions, (sessions, worktreePath) => this.dashboardUiStateStore.orderSessionsForWorktree(sessions, worktreePath));
+        const teammateSessions = this.dashboardPendingActions
+            .applyToSessions(desktopState.teammates ?? [], { includeTeammates: true })
+            .filter((session) => isTeammateSession(session));
+        const orderedTeammates = orderStatuslineItemsByWorktree(teammateSessions, (sessions, worktreePath) => this.dashboardUiStateStore.orderSessionsForWorktree(sessions, worktreePath));
+        const orderedServices = orderStatuslineItemsByWorktree(desktopState.services, (services, worktreePath) => this.dashboardUiStateStore.orderServicesForWorktree(services, worktreePath));
         return {
             project: basename(process.cwd()),
             dashboardScreen: this.dashboardState.screen,
             sessions: [
-                ...desktopState.sessions.map((session) => ({
+                ...orderedSessions.map((session) => ({
                     id: session.id,
                     kind: "agent",
                     tool: session.command,
@@ -173,7 +199,7 @@ export const persistenceMethods = {
                     worktreePath: session.worktreePath,
                     semantic: session.semantic,
                 })),
-                ...desktopState.services.map((service) => ({
+                ...orderedServices.map((service) => ({
                     id: service.id,
                     kind: "service",
                     tool: service.command,
@@ -185,9 +211,26 @@ export const persistenceMethods = {
                     status: service.status,
                     active: service.active,
                     worktreePath: service.worktreePath,
+                    launchCommandLine: service.launchCommandLine,
                 })),
             ],
-            tasks: this.taskDispatcher?.getTaskCounts() ?? { pending: 0, assigned: 0 },
+            teammates: orderedTeammates.map((session) => ({
+                id: session.id,
+                kind: "agent",
+                tool: session.command,
+                label: session.label,
+                tmuxWindowId: session.tmuxWindowId,
+                tmuxWindowIndex: session.tmuxWindowIndex,
+                windowName: session.command,
+                headline: session.headline,
+                status: session.status,
+                role: session.role,
+                active: session.active,
+                worktreePath: session.worktreePath,
+                semantic: session.semantic,
+                team: session.team,
+            })),
+            tasks: exchangeTaskCounts(),
             controlPlane: {
                 daemonAlive: Boolean(loadDaemonInfo()),
                 projectServiceAlive: true,
@@ -203,48 +246,33 @@ export const persistenceMethods = {
         }
         const desktopState = this.desktopStateSnapshot ?? this.buildDesktopStateSnapshot();
         return {
-            sessions: desktopState.sessions,
-            services: desktopState.services,
+            sessions: this.dashboardPendingActions.applyToSessions(desktopState.sessions),
+            teammates: this.dashboardPendingActions
+                .applyToSessions(desktopState.teammates ?? [], { includeTeammates: true })
+                .filter((session) => isTeammateSession(session)),
+            services: this.dashboardPendingActions.applyToServices(desktopState.services),
             statusline: this.buildStatuslineSnapshot(),
-            worktrees: desktopState.worktrees,
+            worktrees: this.dashboardPendingActions.applyToWorktrees(desktopState.worktrees),
             operationFailures: desktopState.operationFailures,
             mainCheckoutInfo: desktopState.mainCheckoutInfo,
             mainCheckoutPath: desktopState.mainCheckoutPath,
         };
     },
     reapplyDashboardPendingActions() {
-        this.dashboardSessionsCache = this.dashboardPendingActions.applyToSessions(this.dashboardSessionsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, ...session }) => session));
-        this.dashboardServicesCache = this.dashboardPendingActions.applyToServices(this.dashboardServicesCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, ...service }) => service));
-        this.dashboardWorktreeGroupsCache = composeDashboardWorktreeGroups(this.dashboardPendingActions.applyToWorktrees(this.dashboardWorktreeGroupsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, pending: _pending, removing: _removing, operationFailure: _operationFailure, ...wt }) => wt)), this.dashboardSessionsCache, this.dashboardServicesCache);
+        this.dashboardSessionsCache = this.dashboardPendingActions.applyToSessions(this.dashboardSessionsCache.map(({ pending: _pending, pendingAction: _pendingAction, optimistic: _optimistic, ...session }) => session));
+        this.dashboardTeammatesCache = this.dashboardPendingActions
+            .applyToSessions((this.dashboardTeammatesCache ?? []).map(({ pending: _pending, pendingAction: _pendingAction, optimistic: _optimistic, ...session }) => session), { includeTeammates: true })
+            .filter((session) => isTeammateSession(session));
+        this.dashboardServicesCache = this.dashboardPendingActions.applyToServices(this.dashboardServicesCache.map(({ pending: _pending, pendingAction: _pendingAction, optimistic: _optimistic, ...service }) => service));
+        this.dashboardWorktreeGroupsCache = this.dashboardUiStateStore.orderWorktreeGroups(composeDashboardWorktreeGroups(this.dashboardPendingActions.applyToWorktrees(this.dashboardWorktreeGroupsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, pending: _pending, removing: _removing, ...wt }) => wt)), this.dashboardSessionsCache, this.dashboardServicesCache));
     },
     listDesktopWorktrees() {
-        const pendingCreates = this.pendingWorktreeCreates;
-        const pendingRemovals = this.pendingWorktreeRemovals;
         const hiddenPaths = listWorktreeGraveyardPaths();
         const worktrees = listAllWorktrees()
             .filter((wt) => !wt.isBare && !hiddenPaths.has(wt.path) && !isToolInternalWorktree(wt))
             .map((wt) => ({
             ...wt,
-            pending: pendingRemovals?.has(wt.path) ?? false,
-            removing: pendingRemovals?.has(wt.path) ?? false,
         }));
-        if (pendingCreates?.size) {
-            for (const path of pendingCreates.keys()) {
-                if (worktrees.some((wt) => wt.path === path))
-                    continue;
-                worktrees.push({
-                    name: basename(path),
-                    path,
-                    branch: "(creating)",
-                    isBare: false,
-                    createdAt: this.worktreeCreateJob?.path === path
-                        ? new Date(this.worktreeCreateJob.startedAt).toISOString()
-                        : undefined,
-                    pending: true,
-                    pendingAction: "creating",
-                });
-            }
-        }
         const worktreePaths = new Set(worktrees.map((worktree) => worktree.path));
         for (const failure of listDashboardOperationFailures()) {
             if (failure.targetKind !== "worktree" || failure.operation !== "create" || !failure.worktreePath)
@@ -264,147 +292,76 @@ export const persistenceMethods = {
         sortDesktopWorktrees(worktrees);
         return worktrees;
     },
+    listProjectedDesktopWorktrees() {
+        return this.dashboardPendingActions.applyToWorktrees(this.listDesktopWorktrees());
+    },
     listWorktreeGraveyardEntries() {
         return listWorktreeGraveyardEntriesImpl();
     },
     async graveyardDesktopWorktree(path) {
-        this.syncSessionsFromState();
         const mainRepo = findMainRepo();
         if (path === mainRepo) {
             throw new Error("Cannot graveyard the main checkout");
         }
-        const matching = listAllWorktrees()
-            .filter((worktree) => !worktree.isBare)
-            .find((worktree) => worktree.path === path);
+        const matching = this.listDesktopWorktrees().find((worktree) => worktree.path === path);
         if (!matching) {
             throw new Error(`Worktree "${path}" not found`);
         }
-        const worktreeGraveyardEntries = this.listWorktreeGraveyardEntries();
-        if (worktreeGraveyardEntries.some((entry) => entry.path === path)) {
-            throw new Error(`Worktree "${matching.name}" is already in the graveyard`);
-        }
-        const attachedServices = collectWorktreeServices(this, path);
-        detachWorktreeServices(this, path);
-        const liveSessions = this.sessions.filter((session) => this.sessionWorktreePaths.get(session.id) === path && this.isSessionRuntimeLive(session) && !session.exited);
-        for (const session of liveSessions) {
-            stopSessionToOffline(this, session);
-        }
-        await waitForWorktreeSessionsToStop(this, path);
-        const attachedAgents = collectWorktreeAgents(this, path);
-        const nextEntries = [
-            ...worktreeGraveyardEntries.filter((entry) => entry.path !== path),
-            {
-                name: matching.name,
-                path: matching.path,
-                branch: matching.branch,
-                createdAt: matching.createdAt,
-                graveyardedAt: new Date().toISOString(),
-                agents: attachedAgents,
-                services: attachedServices,
-            },
-        ];
-        writeWorktreeGraveyardEntries(nextEntries);
-        this.worktreeGraveyardEntries = nextEntries;
-        this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
-        this.saveState();
-        this.invalidateDesktopStateSnapshot();
-        this.refreshLocalDashboardModel();
+        const attachedSession = this.sessions?.find((session) => this.sessionWorktreePaths?.get(session.id) === path && this.isSessionRuntimeLive?.(session));
+        if (attachedSession) {
+            throw new Error(`Cannot graveyard "${matching.name}" while agent "${attachedSession.label || attachedSession.id}" is attached`);
+        }
+        stopWorktreeServicesForGraveyard(this, path);
+        upsertTopologyWorktree({
+            path,
+            name: matching.name,
+            branch: matching.branch,
+            createdAt: matching.createdAt,
+        }, "active");
+        const moved = moveTopologyWorktreeToGraveyard(path, { reason: "user-requested" });
+        if (!moved) {
+            throw new Error(`Unable to graveyard worktree "${path}"`);
+        }
+        this.saveState?.();
+        this.invalidateDesktopStateSnapshot?.();
+        this.refreshLocalDashboardModel?.();
         this.metadataServer?.notifyChange?.();
-        if (this.mode === "dashboard") {
-            this.renderDashboard();
-        }
         return { path, status: "graveyarded" };
     },
     async resurrectGraveyardWorktree(path) {
-        const entries = this.listWorktreeGraveyardEntries();
-        const entry = entries.find((candidate) => candidate.path === path);
-        if (!entry) {
-            throw new Error(`Graveyard worktree "${path}" not found`);
-        }
-        const nextEntries = entries.filter((candidate) => candidate.path !== path);
-        writeWorktreeGraveyardEntries(nextEntries);
-        this.worktreeGraveyardEntries = nextEntries;
-        const flatAgents = takeFlatGraveyardAgentsForWorktree(path);
-        const seen = new Set(this.offlineSessions.map((session) => session.id));
-        for (const agent of [...entry.agents, ...flatAgents]) {
-            if (seen.has(agent.id))
-                continue;
-            this.offlineSessions.push(agent);
-            seen.add(agent.id);
+        if (!existsSync(path)) {
+            throw new Error(`Cannot resurrect worktree "${path}" because the checkout is missing`);
         }
-        const serviceSeen = new Set(this.offlineServices.map((service) => service.id));
-        for (const service of entry.services ?? []) {
-            if (serviceSeen.has(service.id))
-                continue;
-            this.offlineServices.push(service);
-            serviceSeen.add(service.id);
+        const resurrected = resurrectTopologyWorktreeFromGraveyard(path);
+        if (!resurrected) {
+            throw new Error(`Graveyard worktree "${path}" not found`);
         }
-        this.saveState();
-        this.invalidateDesktopStateSnapshot();
-        this.refreshLocalDashboardModel();
+        this.invalidateDesktopStateSnapshot?.();
+        this.refreshLocalDashboardModel?.();
         this.metadataServer?.notifyChange?.();
-        if (this.mode === "dashboard") {
-            this.renderDashboard();
-        }
-        return { path, status: "offline" };
+        return { path, status: "active" };
     },
     async deleteGraveyardWorktree(path) {
-        const entries = this.listWorktreeGraveyardEntries();
-        const entry = entries.find((candidate) => candidate.path === path);
-        if (!entry) {
+        const existing = listTopologyWorktreeGraveyard().find((entry) => entry.path === path);
+        if (!existing) {
             throw new Error(`Graveyard worktree "${path}" not found`);
         }
         const mainRepo = findMainRepo();
-        if (path !== mainRepo) {
-            if (!existsSync(path)) {
-                await removeOrphanedDesktopWorktree(this, mainRepo, path);
-            }
-            else {
-                await new Promise((resolve, reject) => {
-                    let stderr = "";
-                    let child;
-                    try {
-                        child = spawn("git", ["worktree", "remove", path, "--force"], {
-                            cwd: mainRepo,
-                            stdio: ["ignore", "ignore", "pipe"],
-                        });
-                    }
-                    catch (error) {
-                        reject(error);
-                        return;
-                    }
-                    child.stderr.on("data", (chunk) => {
-                        stderr += chunk.toString();
-                    });
-                    child.on("error", reject);
-                    child.on("close", (code) => {
-                        if (code === 0) {
-                            resolve();
-                            return;
-                        }
-                        const detail = stderr
-                            .split("\n")
-                            .map((line) => line.trim())
-                            .filter(Boolean)
-                            .at(-1);
-                        reject(new Error(detail || `git worktree remove exited with code ${code ?? 1}`));
-                    });
-                });
-            }
+        if (path === mainRepo) {
+            throw new Error("Cannot remove the main checkout");
         }
-        const nextEntries = entries.filter((candidate) => candidate.path !== path);
-        writeWorktreeGraveyardEntries(nextEntries);
-        this.worktreeGraveyardEntries = nextEntries;
-        this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
-        this.offlineServices = this.offlineServices.filter((service) => service.worktreePath !== path);
-        removeFlatGraveyardAgentsForWorktree(path);
-        this.saveState();
-        this.invalidateDesktopStateSnapshot();
-        this.refreshLocalDashboardModel();
-        this.metadataServer?.notifyChange?.();
-        if (this.mode === "dashboard") {
-            this.renderDashboard();
+        if (existsSync(path)) {
+            await removeGraveyardedDesktopWorktree(this, mainRepo, path);
         }
+        else {
+            removeWorktreeDependents(this, path);
+            removeTopologyWorktree(path);
+            this.saveState?.();
+        }
+        deleteTopologyWorktreeGraveyardEntry(path);
+        this.invalidateDesktopStateSnapshot?.();
+        this.refreshLocalDashboardModel?.();
+        this.metadataServer?.notifyChange?.();
         return { path, status: "removed" };
     },
     createDesktopWorktree(name) {
@@ -425,6 +382,18 @@ export const persistenceMethods = {
             rejectCreate = reject;
         });
         pendingCreates.set(targetPath, createPromise);
+        const createStartedAt = Date.now();
+        this.worktreeCreateJob = {
+            path: targetPath,
+            name,
+            startedAt: createStartedAt,
+        };
+        upsertTopologyWorktree({
+            path: targetPath,
+            name,
+            branch: name,
+            createdAt: new Date(createStartedAt).toISOString(),
+        }, "creating");
         const clearPendingCreate = () => {
             if (pendingCreates.get(targetPath) === createPromise) {
                 pendingCreates.delete(targetPath);
@@ -433,7 +402,17 @@ export const persistenceMethods = {
                 this.worktreeCreateJob = null;
             }
         };
-        this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(targetPath), "creating", {
+        this.dashboardPendingActions.setWorktreeAction(targetPath, "creating", {
+            worktreeSeed: {
+                name,
+                branch: name,
+                path: targetPath,
+                createdAt: new Date(createStartedAt).toISOString(),
+                status: "offline",
+                isBare: false,
+                sessions: [],
+                services: [],
+            },
             timeoutMs: 180_000,
             onTimeout: () => {
                 clearPendingCreate();
@@ -455,11 +434,6 @@ export const persistenceMethods = {
                 }
             },
         });
-        this.worktreeCreateJob = {
-            path: targetPath,
-            name,
-            startedAt: Date.now(),
-        };
         this.invalidateDesktopStateSnapshot();
         this.refreshLocalDashboardModel();
         if (this.mode === "dashboard") {
@@ -498,9 +472,23 @@ export const persistenceMethods = {
                         reject(new Error(detail || `git worktree add exited with code ${code ?? 1}`));
                     });
                 });
+                upsertTopologyWorktree({
+                    path: targetPath,
+                    name,
+                    branch: name,
+                    basePath: mainRepo,
+                    createdAt: new Date(createStartedAt).toISOString(),
+                }, "active");
                 resolveCreate({ path: targetPath, status: "created" });
             }
             catch (error) {
+                upsertTopologyWorktree({
+                    path: targetPath,
+                    name,
+                    branch: name,
+                    createdAt: new Date(createStartedAt).toISOString(),
+                    operationFailure: error instanceof Error ? error.message : String(error),
+                }, "error");
                 rejectCreate(error);
             }
         })();
@@ -528,7 +516,7 @@ export const persistenceMethods = {
         });
         const finalizeCreate = () => {
             clearPendingCreate();
-            this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(targetPath), null);
+            this.dashboardPendingActions.clearWorktreeAction(targetPath);
             this.invalidateDesktopStateSnapshot();
             this.refreshLocalDashboardModel();
             this.metadataServer?.notifyChange?.();
@@ -541,8 +529,30 @@ export const persistenceMethods = {
     },
     async removeDesktopWorktree(path) {
         const pendingRemovals = this.pendingWorktreeRemovals;
+        const setRemovePending = () => {
+            this.dashboardPendingActions.setWorktreeAction(path, "removing", {
+                timeoutMs: 180_000,
+                onTimeout: () => {
+                    const name = path.split("/").pop() ?? path;
+                    const message = `Timed out removing worktree "${name}"`;
+                    recordDashboardFailure(this, {
+                        targetKind: "worktree",
+                        operation: "remove",
+                        title: `Failed to remove worktree "${name}"`,
+                        message,
+                        worktreePath: path,
+                        worktreeName: name,
+                    });
+                    this.footerFlash = message;
+                    this.footerFlashTicks = 5;
+                    refreshDashboardWorktreeProjection(this);
+                },
+            });
+            refreshDashboardWorktreeProjection(this);
+        };
         const existingRemoval = pendingRemovals.get(path);
         if (existingRemoval) {
+            setRemovePending();
             return existingRemoval;
         }
         let resolveRemoval;
@@ -552,42 +562,18 @@ export const persistenceMethods = {
             rejectRemoval = reject;
         });
         pendingRemovals.set(path, removalPromise);
-        this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(path), "removing", {
-            timeoutMs: 180_000,
-            onTimeout: () => {
-                const name = path.split("/").pop() ?? path;
-                const message = `Timed out removing worktree "${name}"`;
-                recordDashboardFailure(this, {
-                    targetKind: "worktree",
-                    operation: "remove",
-                    title: `Failed to remove worktree "${name}"`,
-                    message,
-                    worktreePath: path,
-                    worktreeName: name,
-                });
-                this.footerFlash = message;
-                this.footerFlashTicks = 5;
-                this.invalidateDesktopStateSnapshot();
-                this.refreshLocalDashboardModel();
-                if (this.mode === "dashboard") {
-                    this.renderDashboard();
-                }
-            },
-        });
-        this.invalidateDesktopStateSnapshot();
-        this.refreshLocalDashboardModel();
-        if (this.mode === "dashboard") {
-            this.renderDashboard();
-        }
+        setRemovePending();
+        let startedRemoval = false;
         void (async () => {
             try {
-                this.syncSessionsFromState();
+                this.syncSessionsFromTopology();
                 const mainRepo = findMainRepo();
                 if (path === mainRepo) {
                     throw new Error("Cannot remove the main checkout");
                 }
                 if (!existsSync(path)) {
                     await removeOrphanedDesktopWorktree(this, mainRepo, path);
+                    removeTopologyWorktree(path);
                     clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                     resolveRemoval({ path, status: "removed" });
                     return;
@@ -597,16 +583,24 @@ export const persistenceMethods = {
                     const worktreeBaseDir = getWorktreeBaseDir();
                     if (path.startsWith(`${worktreeBaseDir}/`) || path === worktreeBaseDir) {
                         await removeOrphanedDesktopWorktree(this, mainRepo, path);
+                        removeTopologyWorktree(path);
                         clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                         resolveRemoval({ path, status: "removed" });
                         return;
                     }
                     throw new Error(`Worktree "${path}" not found`);
                 }
-                const attachedSession = this.sessions.find((session) => session.worktreePath === path && this.isSessionRuntimeLive(session));
+                const attachedSession = this.sessions.find((session) => this.sessionWorktreePaths?.get(session.id) === path && this.isSessionRuntimeLive(session));
                 if (attachedSession) {
                     throw new Error(`Cannot remove "${matching.name}" while agent "${attachedSession.label || attachedSession.id}" is attached`);
                 }
+                upsertTopologyWorktree({
+                    path,
+                    name: matching.name,
+                    branch: matching.branch,
+                    createdAt: matching.createdAt,
+                }, "removing");
+                startedRemoval = true;
                 detachWorktreeServices(this, path);
                 await new Promise((resolve, reject) => {
                     let stderr = "";
@@ -645,14 +639,20 @@ export const persistenceMethods = {
                         reject(new Error(detail || `git worktree remove exited with code ${code ?? 1}`));
                     });
                 });
-                this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
-                this.offlineServices = this.offlineServices.filter((service) => service.worktreePath !== path);
-                removeFlatGraveyardAgentsForWorktree(path);
+                removeWorktreeDependents(this, path);
+                removeTopologyWorktree(path);
                 this.saveState();
                 clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                 resolveRemoval({ path, status: "removed" });
             }
             catch (error) {
+                if (startedRemoval) {
+                    upsertTopologyWorktree({
+                        path,
+                        name: path.split("/").pop() ?? path,
+                        operationFailure: error instanceof Error ? error.message : String(error),
+                    }, "error");
+                }
                 rejectRemoval(error);
             }
         })();
@@ -671,55 +671,39 @@ export const persistenceMethods = {
             this.footerFlashTicks = 5;
         });
         const finalizeRemoval = () => {
-            this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(path), null);
+            this.dashboardPendingActions.clearWorktreeAction(path);
             pendingRemovals.delete(path);
-            this.invalidateDesktopStateSnapshot();
-            this.refreshLocalDashboardModel();
-            this.metadataServer?.notifyChange?.();
-            if (this.mode === "dashboard") {
-                this.renderDashboard();
-            }
+            refreshDashboardWorktreeProjection(this);
         };
         void removalPromise.then(finalizeRemoval, finalizeRemoval);
         return removalPromise;
     },
     listGraveyardEntries() {
-        try {
-            const content = readFileSync(getGraveyardPath(), "utf-8");
-            return JSON.parse(content);
-        }
-        catch {
-            return [];
-        }
+        return listTopologySessionStates({ statuses: ["graveyard"] });
     },
     async resurrectGraveyardSession(sessionId) {
-        this.loadOfflineSessions();
-        const graveyardEntries = this.listGraveyardEntries();
-        const entry = graveyardEntries.find((candidate) => candidate.id === sessionId);
-        if (!entry) {
+        const restored = resurrectTopologySession(sessionId);
+        if (!restored) {
             throw new Error(`Graveyard session "${sessionId}" not found`);
         }
-        const nextGraveyard = graveyardEntries.filter((candidate) => candidate.id !== sessionId);
-        writeFileSync(getGraveyardPath(), JSON.stringify(nextGraveyard, null, 2) + "\n");
-        this.offlineSessions.push(entry);
-        const statePath = getStatePath();
-        try {
-            let state = { savedAt: new Date().toISOString(), cwd: process.cwd(), sessions: [] };
-            if (existsSync(statePath)) {
-                state = JSON.parse(readFileSync(statePath, "utf-8"));
+        const offlineEntry = { ...restored, lifecycle: "offline", status: "offline" };
+        if (Array.isArray(this.offlineSessions)) {
+            const existingIndex = this.offlineSessions.findIndex((session) => session.id === sessionId);
+            if (existingIndex >= 0) {
+                this.offlineSessions[existingIndex] = { ...this.offlineSessions[existingIndex], ...offlineEntry };
+            }
+            else {
+                this.offlineSessions.push(offlineEntry);
             }
-            state.sessions.push(entry);
-            writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n");
         }
-        catch { }
-        debug(`resurrected ${entry.id} from graveyard`, "session");
-        return { sessionId, status: "offline" };
-    },
-    removeSessionsFile() {
-        try {
-            unlinkSync(`${getLocalAimuxDir()}/sessions.json`);
+        this.loadOfflineTopologySessions?.();
+        this.invalidateDesktopStateSnapshot?.();
+        this.writeStatuslineFile?.();
+        this.metadataServer?.notifyChange?.();
+        if (this.mode === "dashboard") {
+            this.renderCurrentDashboardView?.();
         }
-        catch { }
+        return { sessionId, status: "offline" };
     },
     stripAnsi(text) {
         return text.replace(/\u001B\[[0-9;]*m/g, "");
@@ -764,57 +748,53 @@ function sortDesktopWorktrees(worktrees) {
         return a.name.localeCompare(b.name);
     });
 }
-function collectWorktreeAgents(host, path) {
-    const byId = new Map();
-    for (const session of host.offlineSessions) {
-        if (session.worktreePath !== path)
-            continue;
-        byId.set(session.id, session);
-    }
-    return [...byId.values()].sort((a, b) => {
-        const aTime = a.createdAt ? Date.parse(a.createdAt) : 0;
-        const bTime = b.createdAt ? Date.parse(b.createdAt) : 0;
-        return bTime - aTime || a.id.localeCompare(b.id);
-    });
-}
-function collectWorktreeServices(host, path) {
-    const byId = new Map();
-    for (const service of host.offlineServices ?? []) {
-        if (service.worktreePath !== path)
-            continue;
-        byId.set(service.id, service);
-    }
-    for (const service of host.buildLiveServiceStates?.() ?? []) {
-        if (service.worktreePath !== path)
-            continue;
-        byId.set(service.id, service);
-    }
-    return [...byId.values()].sort((a, b) => {
-        const aTime = a.createdAt ? Date.parse(a.createdAt) : 0;
-        const bTime = b.createdAt ? Date.parse(b.createdAt) : 0;
-        return bTime - aTime || a.id.localeCompare(b.id);
-    });
-}
-async function waitForWorktreeSessionsToStop(host, path, timeoutMs = 10_000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const remaining = host.sessions.some((session) => host.sessionWorktreePaths.get(session.id) === path && host.isSessionRuntimeLive(session) && !session.exited);
-        if (!remaining)
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    throw new Error(`Timed out offlining agents for worktree "${basename(path)}"`);
-}
 async function removeOrphanedDesktopWorktree(host, mainRepo, path) {
     await pruneGitWorktrees(mainRepo);
     if (existsSync(path)) {
         rmSync(path, { recursive: true, force: true });
     }
     await pruneGitWorktrees(mainRepo);
-    host.offlineSessions = host.offlineSessions.filter((session) => session.worktreePath !== path);
-    host.offlineServices = host.offlineServices.filter((service) => service.worktreePath !== path);
+    removeWorktreeDependents(host, path);
     host.saveState();
 }
+async function removeGraveyardedDesktopWorktree(host, mainRepo, path) {
+    await removeGitWorktreeCheckout(mainRepo, path);
+    removeWorktreeDependents(host, path);
+    removeTopologyWorktree(path);
+    host.saveState?.();
+}
+async function removeGitWorktreeCheckout(mainRepo, path) {
+    await new Promise((resolve, reject) => {
+        let stderr = "";
+        let child;
+        try {
+            child = spawn("git", ["worktree", "remove", path, "--force"], {
+                cwd: mainRepo,
+                stdio: ["ignore", "ignore", "pipe"],
+            });
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const detail = stderr
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .at(-1);
+            reject(new Error(detail || `git worktree remove exited with code ${code ?? 1}`));
+        });
+    });
+}
 function detachWorktreeServices(host, path) {
     for (const { target, metadata } of host.tmuxRuntimeManager.listProjectManagedWindows(process.cwd())) {
         if (metadata.kind !== "service" || metadata.worktreePath !== path)
@@ -826,6 +806,44 @@ function detachWorktreeServices(host, path) {
         catch { }
     }
     host.offlineServices = host.offlineServices.filter((service) => service.worktreePath !== path);
+    removeTopologyServicesForWorktree(path);
+    removePersistedServicesForWorktree(path);
+}
+function stopWorktreeServicesForGraveyard(host, path) {
+    for (const { target, metadata } of host.tmuxRuntimeManager.listProjectManagedWindows(process.cwd())) {
+        if (metadata.kind !== "service" || metadata.worktreePath !== path)
+            continue;
+        markLifecycleUsed(host, metadata.sessionId);
+        try {
+            host.tmuxRuntimeManager.killWindow(target);
+        }
+        catch { }
+        const serviceState = {
+            id: metadata.sessionId,
+            command: metadata.command,
+            args: metadata.args ?? [],
+            launchCommandLine: metadata.launchCommandLine,
+            worktreePath: metadata.worktreePath,
+            cwd: metadata.worktreePath,
+            label: metadata.label,
+            createdAt: metadata.createdAt,
+        };
+        upsertTopologyService(serviceState, "stopped");
+        host.offlineServices ??= [];
+        const existingIndex = host.offlineServices.findIndex((service) => service.id === metadata.sessionId);
+        if (existingIndex >= 0) {
+            host.offlineServices[existingIndex] = { ...host.offlineServices[existingIndex], ...serviceState };
+        }
+        else {
+            host.offlineServices.push(serviceState);
+        }
+    }
+}
+function removeWorktreeDependents(host, path) {
+    host.offlineSessions = (host.offlineSessions ?? []).filter((session) => session.worktreePath !== path);
+    host.offlineServices = (host.offlineServices ?? []).filter((service) => service.worktreePath !== path);
+    removeTopologySessionsForWorktree(path);
+    removeTopologyServicesForWorktree(path);
     removePersistedServicesForWorktree(path);
 }
 function removePersistedServicesForWorktree(path) {
@@ -856,26 +874,4 @@ function markLifecycleUsed(host, itemId) {
     }
     catch { }
 }
-function takeFlatGraveyardAgentsForWorktree(path) {
-    const graveyardPath = getGraveyardPath();
-    if (!existsSync(graveyardPath))
-        return [];
-    try {
-        const entries = JSON.parse(readFileSync(graveyardPath, "utf-8"));
-        if (!Array.isArray(entries))
-            return [];
-        const matching = entries.filter((entry) => entry?.worktreePath === path);
-        const remaining = entries.filter((entry) => entry?.worktreePath !== path);
-        if (matching.length > 0) {
-            writeFileSync(graveyardPath, JSON.stringify(remaining, null, 2) + "\n");
-        }
-        return matching;
-    }
-    catch {
-        return [];
-    }
-}
-function removeFlatGraveyardAgentsForWorktree(path) {
-    void takeFlatGraveyardAgentsForWorktree(path);
-}
 //# sourceMappingURL=persistence-methods.js.map