aimux-cli 0.1.16 → 0.1.19

package/dist/multiplexer/session-runtime-core.js

@@ -8,12 +8,7 @@ import { SessionRuntime } from "../session-runtime.js";
 import { TmuxSessionTransport } from "../tmux/session-transport.js";
 import { loadMetadataState } from "../metadata-store.js";
 import { parseAgentOutput } from "../agent-output-parser.js";
-import { serializeAgentInput } from "../agent-message-parts.js";
-import { resolveAttachmentPath } from "../attachment-store.js";
-import { appendSessionMessage, readSessionMessages } from "../session-message-history.js";
-import { createSessionInputOperation, saveSessionInputOperation, } from "../session-input-operations.js";
 import { captureGitContext } from "../context/context-bridge.js";
-import { normalizeSubmittedPrompt, paneStillContainsPromptDraft, scheduleTmuxPromptSubmit, } from "../agent-prompt-delivery.js";
 export function getSessionLabel(host, sessionId) {
     return (host.sessionLabels.get(sessionId) ?? host.offlineSessions.find((session) => session.id === sessionId)?.label);
 }
@@ -99,9 +94,6 @@ export function readStatusHeadline(_host, sessionId) {
     }
 }
 export function deriveHeadline(host, sessionId) {
-    const taskDescription = host.taskDispatcher?.getSessionTask(sessionId);
-    if (taskDescription)
-        return taskDescription.slice(0, 80);
     const statusHeadline = readStatusHeadline(host, sessionId);
     if (statusHeadline)
         return statusHeadline;
@@ -153,124 +145,6 @@ export function resolveLiveSessionTmuxTarget(host, sessionId, fallback) {
     catch { }
     return undefined;
 }
-export function writeTmuxAgentInput(host, sessionId, transport, data) {
-    const target = resolveLiveSessionTmuxTarget(host, sessionId, transport.tmuxTarget);
-    if (!target) {
-        throw new Error(`Session "${sessionId}" does not have a live tmux target`);
-    }
-    transport.retarget(target);
-    let textBuffer = "";
-    const flushText = () => {
-        if (!textBuffer)
-            return;
-        host.tmuxRuntimeManager.sendText(target, textBuffer);
-        textBuffer = "";
-    };
-    for (const ch of data) {
-        if (ch === "\r") {
-            flushText();
-            host.tmuxRuntimeManager.sendEnter(target);
-            continue;
-        }
-        if (ch === "\n") {
-            flushText();
-            host.tmuxRuntimeManager.sendKey(target, "C-j");
-            continue;
-        }
-        textBuffer += ch;
-    }
-    flushText();
-}
-export function normalizeAgentInput(host, data, submit, sessionId) {
-    const tool = sessionId ? host.sessionToolKeys?.get(sessionId) : undefined;
-    return normalizeSubmittedPrompt(tool, data, submit);
-}
-export function paneStillContainsAgentDraft(host, target, draft) {
-    return paneStillContainsPromptDraft(host.tmuxRuntimeManager, target, draft);
-}
-export function scheduleTmuxAgentSubmit(host, sessionId, target, draft) {
-    const isTargetCurrent = () => {
-        const currentTarget = resolveLiveSessionTmuxTarget(host, sessionId);
-        return Boolean(currentTarget && currentTarget.windowId === target.windowId);
-    };
-    scheduleTmuxPromptSubmit({
-        tmuxRuntimeManager: host.tmuxRuntimeManager,
-        target,
-        draft,
-        isTargetCurrent,
-    });
-}
-export async function writeAgentInput(host, sessionId, data = "", parts, clientMessageId, submit = false) {
-    const session = resolveRunningSession(host, sessionId);
-    const serializedData = serializeAgentInput({ data, parts }, {
-        tool: host.sessionToolKeys.get(sessionId),
-        resolveAttachmentPath,
-    });
-    const normalizedData = normalizeAgentInput(host, serializedData, submit, sessionId);
-    if (!normalizedData && !submit) {
-        throw new Error("input data is required");
-    }
-    let operation = createSessionInputOperation({ sessionId, clientMessageId, submit });
-    try {
-        const message = appendSessionMessage(sessionId, { data, parts, clientMessageId });
-        if (message?.id) {
-            operation = saveSessionInputOperation({
-                ...operation,
-                messageId: message.id,
-            });
-        }
-        if (session.transport instanceof TmuxSessionTransport) {
-            if (normalizedData) {
-                writeTmuxAgentInput(host, sessionId, session.transport, normalizedData);
-            }
-            operation = saveSessionInputOperation({
-                ...operation,
-                state: submit ? "submitted" : "applied",
-            });
-            if (submit) {
-                const target = resolveLiveSessionTmuxTarget(host, sessionId, session.transport.tmuxTarget);
-                if (!target)
-                    throw new Error(`Session "${sessionId}" does not have a live tmux target`);
-                scheduleTmuxAgentSubmit(host, sessionId, target, normalizedData);
-            }
-        }
-        else {
-            session.write(submit ? `${normalizedData}\r` : normalizedData);
-            operation = saveSessionInputOperation({
-                ...operation,
-                state: submit ? "submitted" : "applied",
-            });
-        }
-        return {
-            sessionId,
-            accepted: true,
-            operation,
-            messageId: message?.id,
-        };
-    }
-    catch (error) {
-        operation = saveSessionInputOperation({
-            ...operation,
-            state: "failed",
-            error: error instanceof Error ? error.message : String(error),
-        });
-        return {
-            sessionId,
-            accepted: false,
-            operation,
-            messageId: operation.messageId,
-            error: operation.error,
-        };
-    }
-}
-export async function readAgentHistory(host, sessionId, lastN) {
-    resolveRunningSession(host, sessionId);
-    return {
-        sessionId,
-        messages: readSessionMessages(sessionId, { lastN: lastN ?? 20 }),
-        lastN: lastN ?? 20,
-    };
-}
 export async function interruptAgent(host, sessionId) {
     const session = resolveRunningSession(host, sessionId);
     if (session.transport instanceof TmuxSessionTransport) {
@@ -285,6 +159,22 @@ export async function interruptAgent(host, sessionId) {
     }
     return { sessionId };
 }
+export async function sendAgentInput(host, sessionId, text) {
+    const session = resolveRunningSession(host, sessionId);
+    if (session.transport instanceof TmuxSessionTransport) {
+        const target = resolveLiveSessionTmuxTarget(host, sessionId, session.transport.tmuxTarget);
+        if (!target)
+            throw new Error(`Session "${sessionId}" does not have a live tmux target`);
+        session.transport.retarget(target);
+        session.transport.write(text);
+        session.transport.write("\r");
+    }
+    else {
+        session.write(text);
+        session.write("\r");
+    }
+    return { sessionId, accepted: true };
+}
 export async function readAgentOutput(host, sessionId, startLine) {
     resolveRunningSession(host, sessionId);
     const target = resolveLiveSessionTmuxTarget(host, sessionId);
@@ -303,13 +193,14 @@ export async function readAgentOutput(host, sessionId, startLine) {
         }),
     };
 }
-export function registerManagedSession(host, session, args, toolConfigKey, worktreePath, role, startTime) {
+export function registerManagedSession(host, session, args, toolConfigKey, worktreePath, role, startTime, team) {
     const existing = host.sessions.find((runtime) => runtime.transport === session);
     if (existing)
         return existing;
     const runtime = new SessionRuntime(session, startTime, {
         onEvent: (event) => host.handleSessionRuntimeEvent(runtime, event),
     });
+    runtime.team = team;
     if (toolConfigKey) {
         host.sessionToolKeys.set(runtime.id, toolConfigKey);
     }
@@ -317,7 +208,10 @@ export function registerManagedSession(host, session, args, toolConfigKey, workt
     if (worktreePath) {
         host.sessionWorktreePaths.set(runtime.id, worktreePath);
     }
-    if (role) {
+    if (team) {
+        host.sessionRoles.delete(runtime.id);
+    }
+    else if (role) {
         host.sessionRoles.set(runtime.id, role);
     }
     else if (!host.sessionRoles.has(runtime.id)) {
@@ -332,7 +226,6 @@ export function registerManagedSession(host, session, args, toolConfigKey, workt
         host.sessionLabels.set(runtime.id, label);
     }
     host.sessions.push(runtime);
-    host.writeSessionsFile();
     host.updateContextWatcherSessions();
     if (host.sessions.length === 1)
         host.contextWatcher.start();
@@ -389,7 +282,9 @@ export function handleSessionRuntimeEvent(host, runtime, event) {
     if (idx === -1)
         return;
     const explicitStop = host.stoppingSessionIds.has(runtime.id);
-    const shouldPreserveOffline = explicitStop || Boolean(runtime.backendSessionId) || uptime >= 10_000;
+    const graveyardAfterStop = host.graveyardAfterStopSessionIds?.has?.(runtime.id) ?? false;
+    const backendSessionId = runtime.backendSessionId;
+    const shouldPreserveOffline = !graveyardAfterStop && (explicitStop || Boolean(backendSessionId) || uptime >= 10_000);
     if (shouldPreserveOffline && !host.offlineSessions.some((entry) => entry.id === runtime.id)) {
         host.offlineSessions.push({
             id: runtime.id,
@@ -399,15 +294,23 @@ export function handleSessionRuntimeEvent(host, runtime, event) {
             args: host.sessionOriginalArgs.get(runtime.id) ?? [],
             lifecycle: "offline",
             createdAt: runtime.startTime ? new Date(runtime.startTime).toISOString() : undefined,
-            backendSessionId: runtime.backendSessionId,
+            backendSessionId,
+            team: runtime.team,
             worktreePath: host.sessionWorktreePaths.get(runtime.id),
             label: host.getSessionLabel(runtime.id),
             headline: host.deriveHeadline(runtime.id),
         });
     }
+    else if (!shouldPreserveOffline) {
+        host.unpreservedExitedSessionIds ??= new Set();
+        host.unpreservedExitedSessionIds.add(runtime.id);
+    }
     host.sessions.splice(idx, 1);
     host.stoppingSessionIds.delete(runtime.id);
-    host.writeSessionsFile();
+    host.graveyardAfterStopSessionIds?.delete?.(runtime.id);
+    if (graveyardAfterStop) {
+        host.offlineSessions = host.offlineSessions.filter((entry) => entry.id !== runtime.id);
+    }
     host.updateContextWatcherSessions();
     const mappedTarget = host.sessionTmuxTargets.get(runtime.id);
     const runtimeTarget = runtime.transport instanceof TmuxSessionTransport ? runtime.transport.tmuxTarget : undefined;
@@ -428,15 +331,17 @@ export function handleSessionRuntimeEvent(host, runtime, event) {
     }
     host.renderDashboard();
 }
-export function buildTmuxWindowMetadata(host, sessionId, command) {
+export function buildTmuxWindowMetadata(host, sessionId, command, existing) {
     const sessionMetadata = loadMetadataState().sessions[sessionId];
+    const runtime = host.sessions.find((session) => session.id === sessionId);
     return {
         kind: "agent",
         sessionId,
         command,
         args: host.sessionOriginalArgs.get(sessionId) ?? [],
         toolConfigKey: host.sessionToolKeys.get(sessionId) ?? command,
-        backendSessionId: host.sessions.find((session) => session.id === sessionId)?.backendSessionId,
+        backendSessionId: runtime?.backendSessionId,
+        team: runtime?.team ?? existing?.team,
         worktreePath: host.sessionWorktreePaths.get(sessionId),
         label: getSessionLabel(host, sessionId),
         role: host.sessionRoles.get(sessionId),
@@ -458,7 +363,7 @@ export function syncTmuxWindowMetadata(host, sessionId) {
             return;
     }
     const existing = host.tmuxRuntimeManager.getWindowMetadata(target);
-    const metadata = buildTmuxWindowMetadata(host, sessionId, runtime.command);
+    const metadata = buildTmuxWindowMetadata(host, sessionId, runtime.command, existing);
     metadata.createdAt =
         existing?.createdAt ??
             (runtime.startTime ? new Date(runtime.startTime).toISOString() : undefined) ??
@@ -479,4 +384,3 @@ export function updateContextWatcherSessions(host) {
         };
     }));
 }
-//# sourceMappingURL=session-runtime-core.js.map

package/dist/multiplexer/subscreens.js

@@ -5,6 +5,10 @@ import { buildThreadEntries, buildWorkflowEntries, filterWorkflowEntries, } from
 import { renderActivityScreen, renderThreadDetails, renderThreadsScreen, renderWorkflowDetails, renderWorkflowScreen, } from "../tui/screens/subscreen-renderers.js";
 import { handleNotificationsKey as handleNotificationsKeyImpl, notificationTargetLabel as notificationTargetLabelImpl, renderNotifications as renderNotificationsImpl, showNotifications as showNotificationsImpl, } from "./notifications.js";
 import { navigationUrgencyScore } from "../fast-control.js";
+function findDashboardSessionOrTeammate(host, sessionId) {
+    return (host.getDashboardSessions?.().find((session) => session.id === sessionId) ??
+        (host.dashboardTeammatesCache ?? []).find((session) => session.id === sessionId));
+}
 export function attentionScore(host, entry) {
     return navigationUrgencyScore(entry);
 }
@@ -409,9 +413,12 @@ export function handleThreadsKey(host, data) {
         const targetSessionId = entry.thread.owner ?? entry.thread.waitingOn?.[0] ?? entry.thread.participants[0];
         if (targetSessionId) {
             markThreadSeen(entry.thread.id, targetSessionId);
-            const dashEntry = host.getDashboardSessions().find((session) => session.id === targetSessionId);
-            if (dashEntry)
-                void host.activateDashboardEntry(dashEntry);
+            const dashEntry = findDashboardSessionOrTeammate(host, targetSessionId);
+            if (dashEntry) {
+                void host.activateDashboardEntry(dashEntry, {
+                    preserveDashboardSelection: Boolean(dashEntry.team),
+                });
+            }
         }
     }
 }
@@ -700,4 +707,3 @@ export async function activateNextAttentionEntry(host) {
     const next = ordered[currentIdx >= 0 ? (currentIdx + 1) % ordered.length : 0];
     await host.activateDashboardEntryByNumber(next.index);
 }
-//# sourceMappingURL=subscreens.js.map

package/dist/multiplexer/tool-picker.js

@@ -300,4 +300,3 @@ export function handleToolOptionsKey(host, data) {
         }
     }
 }
-//# sourceMappingURL=tool-picker.js.map

package/dist/multiplexer/worktree-graveyard.d.ts

@@ -9,5 +9,4 @@ export interface WorktreeGraveyardEntry {
     services?: ServiceState[];
 }
 export declare function listWorktreeGraveyardEntries(): WorktreeGraveyardEntry[];
-export declare function writeWorktreeGraveyardEntries(entries: WorktreeGraveyardEntry[]): void;
 export declare function listWorktreeGraveyardPaths(): Set<string>;

package/dist/multiplexer/worktree-graveyard.js

@@ -1,21 +1,19 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { getWorktreeGraveyardPath } from "../paths.js";
+import { basename } from "node:path";
+import { listTopologySessionStates } from "../runtime-core/topology-sessions.js";
+import { listTopologyServiceStates } from "../runtime-core/topology-services.js";
+import { listTopologyWorktreeGraveyard, listTopologyWorktreeGraveyardPaths, } from "../runtime-core/topology-worktrees.js";
 export function listWorktreeGraveyardEntries() {
-    const path = getWorktreeGraveyardPath();
-    if (!existsSync(path))
-        return [];
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
-export function writeWorktreeGraveyardEntries(entries) {
-    writeFileSync(getWorktreeGraveyardPath(), JSON.stringify(entries, null, 2) + "\n");
+    const sessions = listTopologySessionStates();
+    const services = listTopologyServiceStates();
+    return listTopologyWorktreeGraveyard().map((entry) => ({
+        name: entry.name ?? (basename(entry.path) || entry.path),
+        path: entry.path,
+        branch: entry.branch ?? "",
+        graveyardedAt: entry.graveyardedAt,
+        agents: sessions.filter((session) => session.worktreePath === entry.path),
+        services: services.filter((service) => service.worktreePath === entry.path),
+    }));
 }
 export function listWorktreeGraveyardPaths() {
-    return new Set(listWorktreeGraveyardEntries().map((entry) => entry.path));
+    return listTopologyWorktreeGraveyardPaths();
 }
-//# sourceMappingURL=worktree-graveyard.js.map

package/dist/multiplexer/worktrees.js

@@ -4,18 +4,25 @@ import { parseKeys } from "../key-parser.js";
 import { addDashboardOperationFailure } from "../dashboard/operation-failures.js";
 import { buildWorktreeListOverlayOutput, buildWorktreeRemoveConfirmOverlayOutput, } from "../tui/screens/overlay-renderers.js";
 import { postToProjectService } from "./dashboard-control.js";
-import { DashboardPendingActions } from "../dashboard/pending-actions.js";
 import { dashboardCreatedSortKey } from "../dashboard/sort.js";
 function assertDashboardWorktreeMutationSettled(settled, action) {
     if (!settled) {
         throw new Error(`worktree ${action} did not settle before timing out`);
     }
 }
+function findRenderedWorktreeForSettlement(host, path) {
+    const raw = Array.isArray(host.dashboardRawWorktreeGroupsCache)
+        ? host.dashboardRawWorktreeGroupsCache.find((entry) => entry.path === path)
+        : undefined;
+    if (raw)
+        return raw;
+    return host.dashboardWorktreeGroupsCache.find((entry) => entry.path === path);
+}
 async function waitForRenderedDashboardWorktreeState(host, path, predicate, timeoutMs = 10_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         await host.refreshDashboardModelFromService(true);
-        const group = host.dashboardWorktreeGroupsCache.find((entry) => entry.path === path);
+        const group = findRenderedWorktreeForSettlement(host, path);
         if (predicate(group))
             return true;
         await new Promise((resolve) => setTimeout(resolve, 100));
@@ -23,16 +30,19 @@ async function waitForRenderedDashboardWorktreeState(host, path, predicate, time
     return false;
 }
 async function runDashboardWorktreeMutation(host, opts) {
-    host.dashboardPendingActions.set(opts.pendingKey, opts.pendingAction);
+    host.dashboardPendingActions.setWorktreeAction(opts.pendingPath, opts.pendingAction);
+    host.reapplyDashboardPendingActions?.();
     host.renderDashboard();
     try {
         await opts.request();
         assertDashboardWorktreeMutationSettled(await opts.settle(), opts.pendingAction);
-        host.dashboardPendingActions.set(opts.pendingKey, null);
+        host.dashboardPendingActions.clearWorktreeAction(opts.pendingPath);
+        host.reapplyDashboardPendingActions?.();
         opts.onSuccess?.();
     }
     catch (error) {
-        host.dashboardPendingActions.set(opts.pendingKey, null);
+        host.dashboardPendingActions.clearWorktreeAction(opts.pendingPath);
+        host.reapplyDashboardPendingActions?.();
         opts.onError?.(error);
     }
 }
@@ -45,32 +55,34 @@ function sortDashboardWorktrees(worktrees) {
         return dashboardCreatedSortKey(b) - dashboardCreatedSortKey(a);
     });
 }
+function getOptimisticWorktreeCreatedAt(host, path) {
+    const existing = host.dashboardWorktreeGroupsCache.find((group) => group.path === path);
+    if (typeof existing?.createdAt === "string")
+        return existing.createdAt;
+    host.dashboardOptimisticWorktreeCreatedAt ??= new Map();
+    const cached = host.dashboardOptimisticWorktreeCreatedAt.get(path);
+    if (cached)
+        return cached;
+    const createdAt = new Date().toISOString();
+    host.dashboardOptimisticWorktreeCreatedAt.set(path, createdAt);
+    return createdAt;
+}
 function showOptimisticDashboardWorktreeCreate(host, name) {
     const targetPath = getWorktreeCreatePath(name);
-    const existing = host.dashboardWorktreeGroupsCache.find((group) => group.path === targetPath);
-    if (!existing) {
-        host.dashboardWorktreeGroupsCache = [
-            ...host.dashboardWorktreeGroupsCache,
-            {
-                name,
-                branch: name,
-                path: targetPath,
-                createdAt: new Date().toISOString(),
-                status: "offline",
-                pending: true,
-                pendingAction: "creating",
-                optimistic: true,
-                sessions: [],
-                services: [],
-            },
-        ];
-        sortDashboardWorktrees(host.dashboardWorktreeGroupsCache);
-    }
-    else {
-        existing.pending = true;
-        existing.pendingAction = "creating";
-        existing.optimistic = true;
-    }
+    host.dashboardPendingActions.setWorktreeAction(targetPath, "creating", {
+        worktreeSeed: {
+            name,
+            branch: name,
+            path: targetPath,
+            createdAt: getOptimisticWorktreeCreatedAt(host, targetPath),
+            status: "offline",
+            isBare: false,
+            sessions: [],
+            services: [],
+        },
+    });
+    host.reapplyDashboardPendingActions?.();
+    sortDashboardWorktrees(host.dashboardWorktreeGroupsCache);
     host.dashboardState.focusedWorktreePath = targetPath;
     host.dashboardUiStateStore.markSelectionDirty();
     host.dashboardState.worktreeNavOrder = host.dashboardWorktreeGroupsCache.map((wt) => wt.path);
@@ -94,6 +106,8 @@ function showDashboardWorktreeCreateFailure(host, name, path, error) {
         worktreePath: path,
         worktreeName: name,
     });
+    host.dashboardPendingActions.clearWorktreeAction(path);
+    host.dashboardOptimisticWorktreeCreatedAt?.delete?.(path);
     removeOptimisticDashboardWorktree(host, path);
     host.dashboardWorktreeGroupsCache = [
         ...host.dashboardWorktreeGroupsCache,
@@ -119,6 +133,40 @@ function showDashboardWorktreeCreateFailure(host, name, path, error) {
     host.dashboardUiStateStore.markSelectionDirty();
     host.showDashboardError(`Failed to create "${name}"`, [`Path: ${path}`, `Error: ${message}`]);
 }
+function findDashboardWorktreeCreateFailure(host, path) {
+    const groupFailure = host.dashboardWorktreeGroupsCache?.find((group) => group.path === path)?.operationFailure;
+    if (groupFailure)
+        return groupFailure;
+    return (host.dashboardOperationFailuresCache ?? []).find((failure) => failure.targetKind === "worktree" && failure.operation === "create" && failure.worktreePath === path);
+}
+function isDashboardWorktreeCreateSettled(group) {
+    if (!group)
+        return false;
+    if (group.operationFailure)
+        return false;
+    return group.pending !== true && group.pendingAction !== "creating";
+}
+async function waitForRenderedDashboardWorktreeCreate(host, name, path, timeoutMs = 180_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (typeof host.refreshDashboardModelFromService === "function") {
+            await host.refreshDashboardModelFromService(true);
+        }
+        const failure = findDashboardWorktreeCreateFailure(host, path);
+        if (failure) {
+            const message = typeof failure.message === "string" ? failure.message : "worktree create failed";
+            return { ok: false, error: new Error(message) };
+        }
+        const group = findRenderedWorktreeForSettlement(host, path);
+        if (isDashboardWorktreeCreateSettled(group)) {
+            return { ok: true };
+        }
+        showOptimisticDashboardWorktreeCreate(host, name);
+        host.renderDashboard?.();
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return { ok: false, error: new Error("worktree creating did not settle before timing out") };
+}
 export function showWorktreeCreatePrompt(host) {
     host.openDashboardOverlay("worktree-input");
     host.worktreeInputBuffer = "";
@@ -170,17 +218,27 @@ export function handleWorktreeInputKey(host, data) {
         if (name) {
             if (host.mode === "dashboard") {
                 const targetPath = showOptimisticDashboardWorktreeCreate(host, name);
-                const pendingKey = DashboardPendingActions.worktreeKey(targetPath);
                 host.renderDashboard();
                 void (async () => {
                     try {
                         await postToProjectService(host, "/worktrees/create", { name }, { timeoutMs: 180_000 });
-                        await host.refreshDashboardModelFromService?.(true);
+                        const result = await waitForRenderedDashboardWorktreeCreate(host, name, targetPath);
+                        if (!result.ok) {
+                            throw result.error;
+                        }
                         debug(`worktree created from UI: ${name}`, "worktree");
-                        host.settleDashboardCreatePending?.(pendingKey);
+                        host.dashboardPendingActions.clearWorktreeAction(targetPath);
+                        host.reapplyDashboardPendingActions?.();
+                        host.dashboardOptimisticWorktreeCreatedAt?.delete?.(targetPath);
+                        await host.refreshDashboardModelFromService?.(true);
+                        host.dashboardState.focusedWorktreePath = targetPath;
+                        host.dashboardUiStateStore.markSelectionDirty();
+                        host.renderDashboard();
                     }
                     catch (err) {
-                        host.dashboardPendingActions.set(pendingKey, null);
+                        host.dashboardPendingActions.clearWorktreeAction(targetPath);
+                        host.reapplyDashboardPendingActions?.();
+                        host.dashboardOptimisticWorktreeCreatedAt?.delete?.(targetPath);
                         debug(`worktree create failed: ${err instanceof Error ? err.message : String(err)}`, "worktree");
                         showDashboardWorktreeCreateFailure(host, name, targetPath, err);
                     }
@@ -241,8 +299,6 @@ export function beginWorktreeRemoval(host, path, name, oldIdx) {
         host.renderDashboard();
         return;
     }
-    if (host.pendingWorktreeRemovals?.has?.(path))
-        return;
     debug(`begin worktree graveyard: name=${name} path=${path}`, "worktree");
     host.worktreeRemovalJob = {
         path,
@@ -251,15 +307,12 @@ export function beginWorktreeRemoval(host, path, name, oldIdx) {
         oldIdx,
         stderr: "",
     };
-    host.refreshLocalDashboardModel();
-    host.renderDashboard();
     if (host.mode === "dashboard") {
-        const pendingKey = DashboardPendingActions.worktreeKey(path);
         void runDashboardWorktreeMutation(host, {
-            pendingKey,
+            pendingPath: path,
             pendingAction: "graveyarding",
             request: async () => {
-                await postToProjectService(host, "/worktrees/graveyard", { path }, { timeoutMs: 10_000 });
+                await postToProjectService(host, "/worktrees/graveyard", { path }, { timeoutMs: 180_000 });
             },
             settle: () => waitForRenderedDashboardWorktreeState(host, path, (group) => !group),
             onSuccess: () => {
@@ -276,6 +329,8 @@ export function beginWorktreeRemoval(host, path, name, oldIdx) {
         });
         return;
     }
+    host.refreshLocalDashboardModel();
+    host.renderDashboard();
     void (async () => {
         try {
             await host.graveyardDesktopWorktree(path);
@@ -326,6 +381,7 @@ export function finishWorktreeRemoval(host, code) {
             `Error: ${message}`,
             ...details,
         ]);
+        host.renderDashboard();
         return;
     }
     host.renderDashboard();
@@ -362,4 +418,3 @@ export function handleWorktreeListKey(host, data) {
         host.restoreDashboardAfterOverlayDismiss();
     }
 }
-//# sourceMappingURL=worktrees.js.map

package/dist/notification-context.js

@@ -35,12 +35,16 @@ function isDirectSessionFocus(entry, sessionId) {
 }
 export function updateNotificationContext(source, patch) {
     const state = loadState();
+    const previous = state.contexts[source];
+    const has = (key) => Object.prototype.hasOwnProperty.call(patch, key);
+    const nextSessionId = has("sessionId") ? patch.sessionId : previous?.sessionId;
+    const nextScreen = has("screen") ? patch.screen : has("sessionId") && nextSessionId ? "session" : previous?.screen;
     const next = {
         source,
-        focused: patch.focused ?? state.contexts[source]?.focused ?? false,
-        screen: patch.screen ?? state.contexts[source]?.screen,
-        sessionId: patch.sessionId ?? state.contexts[source]?.sessionId,
-        panelOpen: patch.panelOpen ?? state.contexts[source]?.panelOpen ?? false,
+        focused: has("focused") ? (patch.focused ?? false) : (previous?.focused ?? false),
+        screen: nextScreen,
+        sessionId: nextSessionId,
+        panelOpen: has("panelOpen") ? (patch.panelOpen ?? false) : (previous?.panelOpen ?? false),
         updatedAt: new Date().toISOString(),
     };
     state.contexts[source] = next;
@@ -76,4 +80,3 @@ export function shouldSuppressNotification(event) {
     }
     return false;
 }
-//# sourceMappingURL=notification-context.js.map