@kortix/ui 0.0.0-stage → 0.14.4

package/dist/session/actions/project-session-list-helpers.js

@@ -0,0 +1,339 @@
+import { stripChatMentionMarkup } from './session-label.js';
+/**
+ * Pure helpers extracted from `project-session-list.tsx` so every decision the
+ * sidebar session list makes is unit-testable without mounting react-query or
+ * the row components. Five decisions live here:
+ *
+ * - when to keep polling (`shouldPollProjectSessions`);
+ * - what "last activity" means and how to sort by it
+ *   (`sessionLastActivityAt`, `sortSessionsByLastActivity`) — the same value
+ *   the sidebar's date sections bucket on, see `session-grouping.ts`;
+ * - what a row is titled, and how its timestamp is abbreviated
+ *   (`getSessionDisplayTitle`, `shortRelative`);
+ * - which of loading/error/empty/no-matches/content renders
+ *   (`resolveSessionListViewState`, also read by the Sessions page).
+ *
+ * Display status itself is NOT decided here — `sessionDisplayStatus` in
+ * `packages/ui/src/session/actions/session-label` owns that mapping, and this file reads it.
+ */
+export const LIVE_SESSION_STATUSES = [
+    'queued',
+    'branching',
+    'provisioning',
+];
+/**
+ * Index every change-request state by the session that created it.
+ *
+ * New records use `origin_session_id`. Older records can lack that field, so a
+ * unique `head_ref` → `branch_name` match restores the association. Ambiguous
+ * branches stay unassigned instead of showing a change request on the wrong
+ * session.
+ */
+export function groupChangeRequestsBySession(changeRequests, sessions) {
+    const sessionIds = new Set(sessions.map((session) => session.session_id));
+    const sessionIdsByBranch = new Map();
+    for (const session of sessions) {
+        const branch = session.branch_name?.trim();
+        if (!branch)
+            continue;
+        const matches = sessionIdsByBranch.get(branch) ?? [];
+        matches.push(session.session_id);
+        sessionIdsByBranch.set(branch, matches);
+    }
+    const grouped = new Map();
+    for (const changeRequest of changeRequests) {
+        let sessionId;
+        if (changeRequest.origin_session_id && sessionIds.has(changeRequest.origin_session_id)) {
+            sessionId = changeRequest.origin_session_id;
+        }
+        else if (!changeRequest.origin_session_id) {
+            const branchMatches = sessionIdsByBranch.get(changeRequest.head_ref) ?? [];
+            if (branchMatches.length === 1)
+                sessionId = branchMatches[0];
+        }
+        if (!sessionId)
+            continue;
+        const requests = grouped.get(sessionId) ?? [];
+        requests.push(changeRequest);
+        grouped.set(sessionId, requests);
+    }
+    for (const requests of grouped.values()) {
+        requests.sort((left, right) => {
+            const createdDifference = Date.parse(right.created_at) - Date.parse(left.created_at);
+            return createdDifference || right.number - left.number;
+        });
+    }
+    return grouped;
+}
+/** Whether the session list should keep polling — true while any session is
+ *  still mid-provisioning (queued/branching/provisioning).
+ *
+ *  A warm row (pre-created, never prompted) is skipped: the API reports its
+ *  idle, billed shell as `provisioning` for as long as the box lives
+ *  (KRTX-1466), and polling that static status 5s-fast for up to the warm
+ *  grant would buy nothing — the next real change is the marker drop at the
+ *  first accepted turn, which the open-session interval covers. */
+export function shouldPollProjectSessions(sessions) {
+    return (sessions ?? []).some((session) => LIVE_SESSION_STATUSES.includes(session.status) &&
+        session.metadata?.warm !== true);
+}
+/** Fast poll: a provisioning session changes status within seconds. */
+const PROVISIONING_POLL_MS = 5_000;
+/**
+ * Poll while a session has no name yet. Matched to the title generator's own
+ * budget: `DEFAULT_GENERATION_TIMEOUT_MS` is 15s for at most two bounded gateway
+ * calls, so a 3s poll converges the three surfaces within one tick of the write
+ * instead of leaving them to disagree for up to a minute.
+ */
+const PENDING_TITLE_POLL_MS = 3_000;
+/** Slow poll: fast enough that the relative-time column and the date sections
+ *  follow the conversation you are having, slow enough to be one cheap request
+ *  a minute. */
+const OPEN_SESSION_POLL_MS = 60_000;
+/**
+ * How often the sidebar refetches the session list, or false for not at all.
+ *
+ * Provisioning wins, as it always has. Beyond that the list refetches ONLY
+ * while a session is open, because that is the only time this list goes stale
+ * on its own: every prompt advances the open session's last activity server
+ * side, which is what moves its row between the Today / Yesterday / This week
+ * sections. Without this the row keeps yesterday's section until the page is
+ * reloaded, no matter how long you work in it. A project page with no session
+ * open generates no activity, so it polls nothing.
+ */
+export function projectSessionsRefetchInterval(params) {
+    if (shouldPollProjectSessions(params.sessions))
+        return PROVISIONING_POLL_MS;
+    // A title the server has not written yet. This is the ONLY case where the
+    // client knows something is coming and has no way to be told it arrived —
+    // see `sessionTitleHasLanded`. It outranks the open-session interval because
+    // that one is 60s, four times the title generator's own 15s timeout: the
+    // header sat on "New session" for most of a minute after the name existed.
+    //
+    // Bounded twice, because either bound alone leaks. By the CONDITION: the
+    // moment every session has a name this falls through to the intervals below,
+    // so a settled project page polls nothing. And by AGE
+    // (`TITLE_WAIT_WINDOW_MS`): a session that is never prompted is never named,
+    // and without the window one abandoned row would poll at 3s forever.
+    if (hasSessionAwaitingTitle(params.sessions, params.now ?? Date.now())) {
+        return PENDING_TITLE_POLL_MS;
+    }
+    return params.hasOpenSession ? OPEN_SESSION_POLL_MS : false;
+}
+/** Epoch ms from an ISO string or an epoch-ms number, or null. `metadata` is
+ *  jsonb, so its values arrive as `unknown` and must be proven, not asserted. */
+function activityMs(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value !== 'string' || !value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+/** When the API last accepted a prompt for this session.
+ *
+ * Stamped server-side in the preview proxy the moment a prompt is admitted
+ * (`apps/api/src/projects/session-activity.ts`), so it needs no sandbox
+ * round-trip and cannot silently go missing the way the snapshot below can. */
+function promptActivityMs(session) {
+    return activityMs(session.metadata?.last_activity_at);
+}
+/** Newest conversation update in the runtime's scoped session snapshot, or null
+ *  when the session carries no usable snapshot. */
+function conversationActivityMs(session) {
+    let latest = null;
+    for (const runtimeSession of session.runtime_sessions ?? session.opencode_sessions ?? []) {
+        const parsed = activityMs(runtimeSession.updated_at);
+        if (parsed === null)
+            continue;
+        latest = latest === null ? parsed : Math.max(latest, parsed);
+    }
+    return latest;
+}
+/** The latest real activity for a session, newest evidence first.
+ *
+ * Two independent signals mean "someone used this session", and the newer one
+ * wins because each can lead the other: the prompt stamp lands before the turn
+ * runs, and the conversation snapshot keeps advancing while the agent replies.
+ *
+ *   1. `metadata.last_activity_at` — the API's prompt stamp.
+ *   2. `runtime_sessions[].updated_at` — the runtime's conversation snapshot.
+ *      Real activity, but a LAGGING cache: it is written only by a deferred,
+ *      best-effort sandbox read (`opencode-session-snapshot.ts`), so a session
+ *      whose sandbox was unreachable at that moment has no snapshot at all.
+ *   3. `updated_at` — row bookkeeping, and only reached when neither signal
+ *      above exists.
+ *   4. `created_at` — last resort.
+ *
+ * Step 3 is the fix for the reported bug and it is deliberately a FALLBACK, not
+ * a peer. Bookkeeping writes (runtime stop/resume, title sync, branch
+ * telemetry, mapping repairs) advance `updated_at` without a turn, so it must
+ * never outrank a session that has real activity data. But for a session with
+ * NO activity data, `updated_at` is an upper bound on when it was last touched
+ * while `created_at` is provably not activity at all — which is what pinned a
+ * session that is used every day to the "Older" section of its creation date.
+ * On local data 164 of 181 sessions were in exactly that state. Step 3 retires
+ * itself: any such session gets an exact stamp on its next prompt. */
+export function sessionLastActivityAt(session) {
+    const prompt = promptActivityMs(session);
+    const conversation = conversationActivityMs(session);
+    if (prompt !== null || conversation !== null) {
+        return new Date(Math.max(prompt ?? -Infinity, conversation ?? -Infinity)).toISOString();
+    }
+    return session.updated_at || session.created_at;
+}
+/** Newest-first sort by `sessionLastActivityAt`. */
+export function sortSessionsByLastActivity(sessions) {
+    return sessions.slice().sort((a, b) => {
+        const parsedA = new Date(sessionLastActivityAt(a)).getTime();
+        const parsedB = new Date(sessionLastActivityAt(b)).getTime();
+        const aTime = Number.isFinite(parsedA) ? parsedA : 0;
+        const bTime = Number.isFinite(parsedB) ? parsedB : 0;
+        return bTime - aTime;
+    });
+}
+/** What a row shows before the server has written any name for the session. */
+export const UNTITLED_SESSION_LABEL = 'New session';
+/**
+ * The session's real name, or null while the server has not written one.
+ *
+ * The single resolver behind BOTH `getSessionDisplayTitle` (what the row
+ * renders) and `sessionTitleHasLanded` (whether to keep polling for it). They
+ * must not be two implementations: a predicate that reported "titled" while the
+ * row still showed the placeholder would stop the poll with the UI wrong, which
+ * is the failure mode being fixed here rather than a new one to introduce.
+ *
+ * Precedence: user rename (`custom_name`) → server name → legacy
+ * `metadata.session_name`.
+ */
+function resolveSessionTitle(session) {
+    const legacyMetadataName = typeof session.metadata?.session_name === 'string'
+        ? session.metadata.session_name
+        : null;
+    // Teams wraps a channel @-mention of the bot in `<at>…</at>`; sessions titled
+    // from such a message before the API stripped it still carry the tag.
+    return (stripChatMentionMarkup(session.custom_name ?? '') ||
+        stripChatMentionMarkup(session.name ?? '') ||
+        stripChatMentionMarkup(legacyMetadataName ?? '') ||
+        null);
+}
+/**
+ * Has the server-generated title arrived for this session yet?
+ *
+ * `generateSessionTitleFromFirstPrompt` (apps/api) writes `metadata.name`
+ * fire-and-forget, 3–15s after the first prompt, and emits nothing — no SSE
+ * event, no invalidation. The browser's live event stream comes from opencode
+ * INSIDE the sandbox, so the API has no channel on which to announce it. This
+ * predicate is therefore the only signal a client has, and it is what bounds
+ * the fast poll in `projectSessionsRefetchInterval`.
+ */
+export function sessionTitleHasLanded(session) {
+    return resolveSessionTitle(session) !== null;
+}
+/**
+ * How long after creation a missing title is still worth waiting for.
+ *
+ * A session is named off its FIRST PROMPT. Create one and never prompt it and
+ * no name is ever written — so "untitled" on its own is not evidence that
+ * anything is coming, and treating it as such would put a project page holding
+ * one abandoned session into a permanent 3s poll.
+ *
+ * 2 minutes is deliberately loose against the generator's 15s budget: it has to
+ * cover the create → first-prompt gap for a user who types slowly, and the cost
+ * of being generous is a few extra requests on a page that was just opened.
+ */
+const TITLE_WAIT_WINDOW_MS = 2 * 60_000;
+/**
+ * Is this session still plausibly waiting for a title the server will write?
+ *
+ * Fails CLOSED on an unknown age: an unparseable or missing `created_at` cannot
+ * be proven young, and guessing wrong in that direction is the unbounded poll
+ * this window exists to prevent.
+ *
+ * The window opens from the LATER of creation and last activity. An adopted
+ * warm session was created when the user landed on the project home —
+ * possibly long before the send — but its title generation starts at the
+ * first prompt, i.e. at adoption, which stamps `metadata.last_activity_at`
+ * (apps/api/src/projects/routes/warm-sessions.ts). Windowing on `created_at`
+ * alone skipped the fast poll for exactly the sessions the home send
+ * produces.
+ */
+export function isAwaitingTitle(session, now) {
+    if (sessionTitleHasLanded(session))
+        return false;
+    const createdAt = Date.parse(session.created_at ?? '');
+    if (!Number.isFinite(createdAt))
+        return false;
+    const windowStart = Math.max(createdAt, promptActivityMs(session) ?? createdAt);
+    return now - windowStart <= TITLE_WAIT_WINDOW_MS;
+}
+/** Is any session in the list still waiting for its title? */
+export function hasSessionAwaitingTitle(sessions, now) {
+    return (sessions ?? []).some((session) => isAwaitingTitle(session, now));
+}
+/**
+ * Display title for a session row. Precedence: user rename (custom_name) →
+ * server name → legacy metadata.session_name → the untitled placeholder.
+ */
+export function getSessionDisplayTitle(session) {
+    // Untitled (the real title lands seconds after the first prompt): a humane
+    // static label beats a raw branch-hash slice in the sidebar.
+    return resolveSessionTitle(session) ?? UNTITLED_SESSION_LABEL;
+}
+/** Compresses date-fns' `formatDistanceToNowStrict` output ("5 minutes") down
+ *  to the sidebar's fixed-width form ("5m") so the relative-time column never
+ *  reflows the row. "0 seconds" and "less than a minute" both collapse to
+ *  "now". Unrecognized input (a future date-fns phrasing change, or a locale
+ *  string) is passed through unchanged rather than dropped. */
+export function shortRelative(input) {
+    if (input === 'less than a minute')
+        return 'now';
+    const match = input.match(/^(\d+)\s+(second|minute|hour|day|month|year)s?$/);
+    if (!match)
+        return input;
+    if (match[1] === '0' && match[2] === 'second')
+        return 'now';
+    const [, n, unit] = match;
+    const suffix = unit === 'second'
+        ? 's'
+        : unit === 'minute'
+            ? 'm'
+            : unit === 'hour'
+                ? 'h'
+                : unit === 'day'
+                    ? 'd'
+                    : unit === 'month'
+                        ? 'mo'
+                        : 'y';
+    return `${n}${suffix}`;
+}
+/** KRTX-1727: the server drops rows the viewer may not see after a bounded
+ *  scan, so zero rows with a cursor left is not an empty list. While the list
+ *  reads past empty pages on its own (`scanning`) it is loading; after that,
+ *  `more` offers Load more instead of "No sessions yet". */
+export function resolveSessionListViewState(params) {
+    if (!params.hasData)
+        return params.isError ? 'error' : 'loading';
+    if (params.totalCount === 0 && params.scanning)
+        return 'loading';
+    if (params.totalCount === 0 && params.hasMore)
+        return 'more';
+    if (params.totalCount === 0)
+        return params.serverFiltered ? 'no-matches' : 'empty';
+    if (params.visibleCount === 0)
+        return 'no-matches';
+    return 'content';
+}
+/**
+ * Which sidebar section a session's RUN lives in, from its `initiator`: another
+ * member's run is Shared, an automated run (trigger, channel, API, platform) is
+ * Automated, and the viewer's own run (or an unclassified row) is neither.
+ */
+export function starterSectionOf(session, viewerId) {
+    const initiator = session.initiator;
+    if (!initiator)
+        return session.is_owner === false ? 'shared' : null;
+    if (initiator.type !== 'member')
+        return 'automated';
+    return initiator.id && viewerId && initiator.id !== viewerId ? 'shared' : null;
+}

package/dist/session/actions/rename-session-cache.d.ts

@@ -0,0 +1,35 @@
+import type { ProjectSession } from '@kortix/sdk';
+/**
+ * Writes a rename into a project-session list without touching any other row.
+ *
+ * Extracted so the rename mutation's `onMutate` (optimistic write, fired
+ * before the request lands) and a plain unit test call the SAME function —
+ * no React Query, no network, no mock. `qk.project.sessions(projectId)` has
+ * seven readers (sidebar, session list, tab bar, command palette, review
+ * center, gateway overview); writing here settles all of them at once instead
+ * of waiting for the post-mutation refetch.
+ *
+ * Total: a `sessionId` that is not in `sessions` returns `sessions` UNCHANGED
+ * (same array reference) rather than throwing — `onMutate` runs against a
+ * client-cached snapshot that can already be stale by the time it fires (the
+ * row may have been deleted, or the cache may not be populated yet).
+ *
+ * `name` mirrors the API's own clear-vs-set rule
+ * (`apps/api/src/projects/routes/r7.ts`): an empty string clears the override
+ * (`custom_name: null`, reverting to the auto title) rather than storing `''`.
+ */
+export declare function applySessionRename(sessions: ProjectSession[], sessionId: string, name: string): ProjectSession[];
+/**
+ * `onSuccess`'s cache write: the rename's authoritative result, merged onto the
+ * row that is already cached.
+ *
+ * MERGED, not replaced. `PATCH /projects/:id/sessions/:id` serializes its
+ * response with `serializeSession(row, { grants, viewerId, canManageProject })`
+ * (`apps/api/src/projects/routes/r7.ts`) — it passes no `ownerEmail`,
+ * `ownerName`, `runtimeStatus` or `deletedAt`, so those come back `null` even
+ * though the LIST endpoint resolves and populates them. Writing the response
+ * wholesale therefore blanked `owner_email` on a SHARED session — the field
+ * `share-session-modal.tsx` reads for "shared by X" — until `onSettled`'s
+ * refetch landed. Only the three fields this endpoint actually owns are taken.
+ */
+export declare function applyRenameResponse(sessions: ProjectSession[], updated: ProjectSession): ProjectSession[];

package/dist/session/actions/rename-session-cache.js

@@ -0,0 +1,50 @@
+/**
+ * Writes a rename into a project-session list without touching any other row.
+ *
+ * Extracted so the rename mutation's `onMutate` (optimistic write, fired
+ * before the request lands) and a plain unit test call the SAME function —
+ * no React Query, no network, no mock. `qk.project.sessions(projectId)` has
+ * seven readers (sidebar, session list, tab bar, command palette, review
+ * center, gateway overview); writing here settles all of them at once instead
+ * of waiting for the post-mutation refetch.
+ *
+ * Total: a `sessionId` that is not in `sessions` returns `sessions` UNCHANGED
+ * (same array reference) rather than throwing — `onMutate` runs against a
+ * client-cached snapshot that can already be stale by the time it fires (the
+ * row may have been deleted, or the cache may not be populated yet).
+ *
+ * `name` mirrors the API's own clear-vs-set rule
+ * (`apps/api/src/projects/routes/r7.ts`): an empty string clears the override
+ * (`custom_name: null`, reverting to the auto title) rather than storing `''`.
+ */
+export function applySessionRename(sessions, sessionId, name) {
+    const index = sessions.findIndex((session) => session.session_id === sessionId);
+    if (index === -1)
+        return sessions;
+    const next = sessions.slice();
+    next[index] = { ...next[index], custom_name: name || null };
+    return next;
+}
+/**
+ * `onSuccess`'s cache write: the rename's authoritative result, merged onto the
+ * row that is already cached.
+ *
+ * MERGED, not replaced. `PATCH /projects/:id/sessions/:id` serializes its
+ * response with `serializeSession(row, { grants, viewerId, canManageProject })`
+ * (`apps/api/src/projects/routes/r7.ts`) — it passes no `ownerEmail`,
+ * `ownerName`, `runtimeStatus` or `deletedAt`, so those come back `null` even
+ * though the LIST endpoint resolves and populates them. Writing the response
+ * wholesale therefore blanked `owner_email` on a SHARED session — the field
+ * `share-session-modal.tsx` reads for "shared by X" — until `onSettled`'s
+ * refetch landed. Only the three fields this endpoint actually owns are taken.
+ */
+export function applyRenameResponse(sessions, updated) {
+    return sessions.map((session) => session.session_id === updated.session_id
+        ? {
+            ...session,
+            name: updated.name,
+            custom_name: updated.custom_name,
+            updated_at: updated.updated_at,
+        }
+        : session);
+}

package/dist/session/actions/session-delete-modal.d.ts

@@ -0,0 +1,17 @@
+/** Days a deleted session stays restorable (`SESSION_DELETE_ROWS_DAYS` in the API). */
+export declare const RESTORE_DAYS = 30;
+/** How long the delete toast offers Undo. */
+export declare const UNDO_TOAST_MS = 8000;
+/** Restore a deleted session, retrying while its old sandbox is still being removed.
+ *  Undo here, and Restore session under Recently deleted (KRTX-2853). */
+export declare function restoreWhenRemoved(projectId: string, sessionId: string): Promise<void>;
+interface SessionDeleteModalProps {
+    projectId: string;
+    sessionId: string | null;
+    sessionLabel?: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onDeleted?: () => void;
+}
+export declare function SessionDeleteModal({ projectId, sessionId, sessionLabel, open, onOpenChange, onDeleted, }: SessionDeleteModalProps): import("react").JSX.Element;
+export {};

package/dist/session/actions/session-delete-modal.js

@@ -0,0 +1,128 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { sessionIdFromPath, uiRoutes } from '../../lib/routes.js';
+import { ConfirmDialog } from '../../primitives/confirm-dialog.js';
+import { IconDelete } from '../../primitives/kortix-icons.js';
+import { dismissToast, errorToast, progressToast, successToast, undoToast, } from '../../primitives/toast.js';
+import { deleteProjectSession, restoreProjectSession } from '@kortix/sdk';
+import { qk, removeCachedProjectSession } from '@kortix/sdk/react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useUiPathname, useUiRouter } from '../../providers/ui-provider.js';
+import { useSessionIds } from '../../providers/session-ids.js';
+import { useTranslations } from '../../i18n/index.js';
+/** Days a deleted session stays restorable (`SESSION_DELETE_ROWS_DAYS` in the API). */
+export const RESTORE_DAYS = 30;
+/** How long the delete toast offers Undo. */
+export const UNDO_TOAST_MS = 8000;
+/**
+ * The waits between restore attempts while the API answers 409
+ * `session_sandbox_removal_pending`: the provider usually confirms the old
+ * sandbox removed within seconds of the delete.
+ */
+const RESTORE_RETRY_MS = [2_000, 4_000, 8_000, 16_000];
+const removalPending = (err) => err?.code === 'session_sandbox_removal_pending';
+/** Restore a deleted session, retrying while its old sandbox is still being removed.
+ *  Undo here, and Restore session under Recently deleted (KRTX-2853). */
+export async function restoreWhenRemoved(projectId, sessionId) {
+    for (const wait of RESTORE_RETRY_MS) {
+        try {
+            await restoreProjectSession(projectId, sessionId);
+            return;
+        }
+        catch (err) {
+            if (!removalPending(err))
+                throw err;
+            await new Promise((resolve) => setTimeout(resolve, wait));
+        }
+    }
+    await restoreProjectSession(projectId, sessionId);
+}
+export function SessionDeleteModal({ projectId, sessionId, sessionLabel, open, onOpenChange, onDeleted, }) {
+    const tHardcodedUi = useTranslations('hardcodedUi');
+    const t = useTranslations('sessionDelete');
+    const tCommon = useTranslations('common');
+    const queryClient = useQueryClient();
+    const router = useUiRouter();
+    // The session the page shows: the host's ids, else its session URL.
+    const pathname = useUiPathname();
+    const openSessionId = useSessionIds().sessionId ?? sessionIdFromPath(pathname, projectId);
+    // Runs from the toast, after the dialog closed (and maybe unmounted).
+    const undoDelete = async (id, toastId) => {
+        dismissToast(toastId);
+        const progressId = progressToast(t('restoring'));
+        try {
+            await restoreWhenRemoved(projectId, id);
+        }
+        catch (err) {
+            errorToast(err instanceof Error && err.message ? err.message : t('restoreFailed'), 
+            // Undo is the only restore in the web app: keep a way to try again.
+            removalPending(err)
+                ? {
+                    id: toastId,
+                    duration: UNDO_TOAST_MS,
+                    actions: [{ label: tCommon('retry'), onClick: () => void undoDelete(id, toastId) }],
+                }
+                : undefined);
+            return;
+        }
+        finally {
+            dismissToast(progressId);
+        }
+        successToast(t('restored'));
+        void queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(projectId) });
+        // Deleting the open session left its page: Undo goes back to it.
+        if (id === openSessionId)
+            router.push(uiRoutes().session(projectId, id));
+    };
+    const deleteMutation = useMutation({
+        mutationFn: (id) => deleteProjectSession(projectId, id),
+        // The row leaves every cached list the moment the user confirms, not when
+        // the server does. Returns the restore for `onError`. Not for the session
+        // this route renders: removing its row entry makes the page's own readers
+        // (header, chat, the runtime pin) refetch a session that is being deleted.
+        onMutate: (id) => id === openSessionId ? undefined : removeCachedProjectSession(queryClient, projectId, id),
+        onSuccess: (_result, id) => {
+            const toastId = `session-delete-undo-${id}`;
+            undoToast(sessionLabel
+                ? tHardcodedUi('i18nComplete.text0690079160b0', { value0: sessionLabel })
+                : tHardcodedUi.raw('i18nComplete.text3c0cf36859ac'), {
+                id: toastId,
+                duration: UNDO_TOAST_MS,
+                icon: _jsx(IconDelete, { className: "size-4" }),
+                undoLabel: t('undo'),
+                onUndo: () => void undoDelete(id, toastId),
+            });
+            // Every list refetches. The deleted session's own reads do not: they
+            // would answer 404 while the page they sit on navigates away.
+            const own = qk.project.session(projectId, id);
+            void queryClient.invalidateQueries({
+                queryKey: qk.project.sessionsScope(projectId),
+                predicate: (q) => !own.every((part, i) => q.queryKey[i] === part),
+            });
+            // The open session's page has nothing left to show: a caller without
+            // its own destination (the sidebar row menu) leaves it for the project home.
+            if (onDeleted)
+                onDeleted();
+            else if (id === openSessionId)
+                router.push(uiRoutes().project(projectId));
+            onOpenChange(false);
+        },
+        onError: (err, _id, restore) => {
+            restore?.();
+            errorToast(err instanceof Error ? err.message : tHardcodedUi.raw('i18nComplete.text5c9c6608b47d'));
+        },
+    });
+    const confirmDelete = () => {
+        if (!sessionId || deleteMutation.isPending)
+            return;
+        deleteMutation.mutate(sessionId);
+    };
+    return (_jsx(ConfirmDialog, { open: open, onOpenChange: (o) => {
+            if (!deleteMutation.isPending)
+                onOpenChange(o);
+        }, title: tHardcodedUi.raw('componentsProjectsProjectSessionList.line189JsxTextDeleteSession'), description: t.rich('description', {
+            label: sessionLabel ?? '',
+            days: RESTORE_DAYS,
+            name: (chunks) => _jsx("span", { className: "text-foreground font-medium", children: chunks }),
+        }), confirmLabel: tHardcodedUi.raw('i18nComplete.texte2d0a54968ea'), confirmVariant: "destructive", isPending: deleteMutation.isPending, onConfirm: confirmDelete }));
+}