` — so inline spans are
- * tagged on the mdast, where the distinction still exists. Code inside a link
- * label stays untagged: linkifying it would nest an anchor inside the link's
- * anchor and steal its clicks.
+ * Preserve Windows drive links as allowed `file:` URLs before sanitization.
+ * The same traversal tags inline code while it can still be distinguished
+ * from fenced code. Code inside links stays untagged to avoid nested anchors.
*/
-function remarkTagInlineCode() {
+function remarkNormalizeLinksAndTagInlineCode() {
return (tree: MarkdownAstNode) => {
const visit = (node: MarkdownAstNode, insideLink: boolean) => {
+ if (
+ (node.type === "link" || node.type === "definition") &&
+ typeof node.url === "string" &&
+ WINDOWS_DRIVE_PATH_REGEX.test(node.url)
+ ) {
+ node.url = `file:///${node.url.replaceAll("\\", "/")}`;
+ }
if (node.type === "inlineCode" && !insideLink) {
node.data = {
...node.data,
@@ -869,7 +924,6 @@ interface MarkdownFileLinkProps {
className?: string | undefined;
}
-const MARKDOWN_LINK_HREF_PATTERN = /\[[^\]]*]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g;
const MARKDOWN_FILE_LINK_CLASS_NAME =
"chat-markdown-file-link cursor-pointer transition-colors hover:bg-accent/70";
@@ -882,14 +936,12 @@ function pathParentSegments(path: string): string[] {
function buildFileLinkParentSuffixByPath(filePaths: ReadonlyArray): Map {
const groups = new Map>();
for (const filePath of filePaths) {
- const pathSegments = filePath
- .replaceAll("\\", "/")
- .split("/")
- .filter((segment) => segment.length > 0);
+ const normalizedPath = filePath.replaceAll("\\", "/");
+ const pathSegments = normalizedPath.split("/").filter((segment) => segment.length > 0);
const basename = pathSegments[pathSegments.length - 1];
if (!basename) continue;
const group = groups.get(basename) ?? new Set();
- group.add(filePath);
+ group.add(normalizedPath);
groups.set(basename, group);
}
@@ -948,19 +1000,12 @@ function extractInlineCodeSpans(text: string): string[] {
return spans;
}
-function extractMarkdownLinkHrefs(text: string): string[] {
- const hrefs: string[] = [];
- for (const match of text.matchAll(MARKDOWN_LINK_HREF_PATTERN)) {
- const href = match[1]?.trim();
- if (!href) continue;
- hrefs.push(href);
- }
- return hrefs;
-}
-
function normalizeMarkdownLinkHrefKey(href: string): string {
const normalizedHref = normalizeMarkdownLinkDestination(href);
- return rewriteMarkdownFileUriHref(normalizedHref) ?? normalizedHref;
+ const rewrittenHref = rewriteMarkdownFileUriHref(normalizedHref) ?? normalizedHref;
+ return WINDOWS_DRIVE_PATH_REGEX.test(rewrittenHref)
+ ? rewrittenHref.replaceAll("\\", "/")
+ : rewrittenHref;
}
const MARKDOWN_LINK_FAVICON_CLASS_NAME = "block size-full shrink-0 select-none";
@@ -994,51 +1039,58 @@ const MarkdownLinkFavicon = memo(function MarkdownLinkFavicon({ host }: { host:
);
});
-const MARKDOWN_IMAGE_CLASS_NAME =
- "my-2 max-h-[28rem] max-w-full rounded-md border border-border/60 object-contain bg-muted/20";
+const CHAT_MARKDOWN_IMAGE_SIZE_CLASS_NAME =
+ "h-auto w-auto max-h-[30rem] max-w-[min(100%,30rem)] object-contain";
-const MarkdownWorkspaceImage = memo(function MarkdownWorkspaceImage({
- src,
- alt,
- threadRef,
- className,
- ...props
-}: {
- src: string;
- alt?: string | undefined;
- threadRef: ScopedThreadRef;
- className?: string | undefined;
-} & Omit, "src" | "alt" | "className">) {
- const localPath = normalizeLocalMarkdownImageSrc(src);
- const assetUrl = useAssetUrl(threadRef.environmentId, {
+// block! outranks the unlayered `.chat-markdown img { display: inline-block }`
+// rule, keeping workspace images on the same block layout as their placeholder.
+const CHAT_MARKDOWN_WORKSPACE_IMAGE_CLASS_NAME = cn(
+ CHAT_MARKDOWN_IMAGE_SIZE_CLASS_NAME,
+ "my-1 block! rounded-lg border border-border/40",
+);
+
+function ChatMarkdownImageFallback(props: { readonly alt: string }) {
+ return (
+
+ (null);
- if (failed || assetUrl === null) {
+ if (assetUrl._tag === "Failure" || (assetUrl._tag === "Success" && failedUrl === assetUrl.url)) {
+ return 
setFailed(true)}
+ draggable={false}
+ className={CHAT_MARKDOWN_WORKSPACE_IMAGE_CLASS_NAME}
+ onError={() => setFailedUrl(assetUrl.url)}
/>
);
});
@@ -1400,7 +1452,11 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
onClick={(event) => {
event.preventDefault();
event.stopPropagation();
- if (onOpenInBrowser) {
+ if (shouldOpenMarkdownFileLinkInEditor(event)) {
+ handleOpenInEditor();
+ return;
+ }
+ if (onOpenInBrowser && shouldOpenMarkdownFileLinkInBrowserByDefault(iconPath)) {
handleOpenInBrowser();
return;
}
@@ -1416,8 +1472,10 @@ const MarkdownFileLink = memo(function MarkdownFileLink({
side="top"
className="max-w-[min(40rem,calc(100vw-2rem))] font-mono text-[11px] leading-tight"
>
-
- {displayPath}
+ {/* The full path: the chip already shows the shortened form, and a link
+ to the workspace root collapses to a bare label that repeats it. */}
+
+ {targetPath}
@@ -1467,9 +1525,16 @@ function ChatMarkdown({
const openPreview = useAtomCommand(previewEnvironment.open, {
reportFailure: false,
});
+ const updateThreadMetadata = useAtomCommand(threadEnvironment.updateMetadata, {
+ reportFailure: false,
+ });
const preparedConnection = usePreparedConnection(threadRef?.environmentId ?? null);
const environmentId = useActiveEnvironmentId();
const serverConfig = useAtomValue(serverEnvironment.configValueAtom(environmentId));
+ const threadServerConfig = useAtomValue(
+ serverEnvironment.configValueAtom(threadRef?.environmentId ?? environmentId),
+ );
+ const projects = useProjects();
const openInPreferredEditor = useOpenInPreferredEditor(
environmentId,
serverConfig?.availableEditors ?? [],
@@ -1523,6 +1588,54 @@ function ChatMarkdown({
event.clipboardData.setData("text/html", payload.html);
}, []);
const openChangeRequestLink = useOpenChangeRequestLink(threadRef);
+ const resolveThreadPullRequest = useCallback(
+ (href: string): ThreadLinkedPullRequest | null => {
+ if (
+ threadRef === undefined ||
+ readThreadShell(threadRef) === null ||
+ threadServerConfig?.environment.capabilities.threadPullRequestLinking !== true
+ ) {
+ return null;
+ }
+ const parsed = parseChangeRequestUrl(href);
+ if (parsed === null) return null;
+ const project = findProjectForChangeRequest(
+ projects.filter((candidate) => candidate.environmentId === threadRef.environmentId),
+ parsed,
+ );
+ if (project === undefined) return null;
+ return {
+ projectId: project.id,
+ repository: project.repositoryIdentity?.displayName ?? parsed.repository,
+ number: parsed.number,
+ url: href,
+ };
+ },
+ [projects, threadRef, threadServerConfig],
+ );
+ const updateThreadPullRequestLink = useCallback(
+ async (href: string, linked: boolean) => {
+ if (threadRef === undefined) return;
+ const linkedPullRequest = linked ? resolveThreadPullRequest(href) : null;
+ if (linked && linkedPullRequest === null) {
+ throw new Error("The pull request is not available in this environment.");
+ }
+ if (!linked) {
+ const currentPullRequest = readThreadShell(threadRef)?.linkedPullRequest;
+ if (currentPullRequest == null || !matchesLinkedPullRequestUrl(currentPullRequest, href)) {
+ return;
+ }
+ }
+ const result = await updateThreadMetadata({
+ environmentId: threadRef.environmentId,
+ input: { threadId: threadRef.threadId, linkedPullRequest },
+ });
+ if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+ throw squashAtomCommandFailure(result);
+ }
+ },
+ [resolveThreadPullRequest, threadRef, updateThreadMetadata],
+ );
const openExternalLinkInPreview = useCallback(
(url: string) => {
if (!threadRef) {
@@ -1609,7 +1722,9 @@ function ChatMarkdown({
copyMarkdown: string,
className?: string,
) => {
- const parentSuffix = fileLinkParentSuffixByPath.get(fileLinkMeta.filePath);
+ const parentSuffix = fileLinkParentSuffixByPath.get(
+ fileLinkMeta.filePath.replaceAll("\\", "/"),
+ );
const labelParts = [fileLinkMeta.basename];
if (typeof parentSuffix === "string" && parentSuffix.length > 0) {
labelParts.push(parentSuffix);
@@ -1647,30 +1762,6 @@ function ChatMarkdown({
};
return {
- img({ node: _node, src, alt, className, title: _title, ...props }) {
- const srcValue = typeof src === "string" ? src : undefined;
- if (srcValue && isLocalMarkdownImageSrc(srcValue) && threadRef) {
- return (
- 
- );
- },
p({ node: _node, children, ...props }) {
return {renderSkillInlineMarkdownChildren(children, skills)}
;
},
@@ -1744,7 +1835,10 @@ function ChatMarkdown({
},
a({ node, href, children, title: _title, ...props }) {
const normalizedHref = href ? normalizeMarkdownLinkHrefKey(href) : "";
- const fileLinkMeta = normalizedHref ? markdownFileLinkMetaByHref.get(normalizedHref) : null;
+ const fileLinkMeta = normalizedHref
+ ? (markdownFileLinkMetaByHref.get(normalizedHref) ??
+ resolveMarkdownFileLinkMeta(normalizedHref, cwd))
+ : null;
if (!fileLinkMeta) {
const faviconHost = resolveExternalWebLinkHost(href);
const isSameDocumentLink = href?.startsWith("#") ?? false;
@@ -1774,9 +1868,20 @@ function ChatMarkdown({
event.stopPropagation();
const api = readLocalApi();
if (!api) return;
+ const pullRequest = resolveThreadPullRequest(href);
+ const currentPullRequest =
+ threadRef === undefined ? null : readThreadShell(threadRef)?.linkedPullRequest;
+ const threadLinkAction =
+ currentPullRequest != null &&
+ matchesLinkedPullRequestUrl(currentPullRequest, href)
+ ? "unlink-from-thread"
+ : pullRequest === null
+ ? undefined
+ : "link-to-thread";
void showExternalLinkContextMenu({
href,
canOpenInPreview,
+ threadLinkAction,
position: { x: event.clientX, y: event.clientY },
showContextMenu: (items, position) => api.contextMenu.show(items, position),
openInPreview: async (target) => {
@@ -1790,8 +1895,25 @@ function ChatMarkdown({
},
openExternal: (target) => api.shell.openExternal(target),
copyLink: (target) => writeTextToClipboard(target, "link"),
+ updateThreadLink: updateThreadPullRequestLink,
reportFailure: (operation, cause) => {
reportMarkdownActionFailure({ operation, target: href }, cause);
+ if (
+ operation === "link-pull-request-to-thread" ||
+ operation === "unlink-pull-request-from-thread"
+ ) {
+ toastManager.add(
+ stackedThreadToast({
+ type: "error",
+ title:
+ operation === "link-pull-request-to-thread"
+ ? "Unable to link pull request"
+ : "Unable to unlink pull request",
+ description:
+ cause instanceof Error ? cause.message : "The request failed.",
+ }),
+ );
+ }
},
});
}}
@@ -1843,6 +1965,43 @@ function ChatMarkdown({
);
},
+ img({ node: _node, title: _title, src, alt, ...props }) {
+ const srcString = typeof src === "string" ? normalizeMarkdownLinkDestination(src) : "";
+ const altText = alt ?? "";
+ const imageSource = classifyMarkdownImageSource(srcString, cwd);
+ if (imageSource._tag === "Direct") {
+ return (
+ 
+ );
+ }
+ if (imageSource._tag === "WorkspaceFile" && threadRef) {
+ return (
+ ,
+ assetState: "success" as "success" | "loading",
+}));
+
+vi.mock("@effect/atom-react", () => ({ useAtomValue: () => null }));
+vi.mock("../assets/assetUrls", () => ({
+ useAssetUrlState: (_environmentId: unknown, resource: unknown) => {
+ testState.resources.push(resource);
+ return testState.assetState === "loading"
+ ? { _tag: "Loading" }
+ : { _tag: "Success", url: "https://signed.test/workspace-image.svg" };
+ },
+}));
+vi.mock("../hooks/useTheme", () => ({ useTheme: () => ({ resolvedTheme: "dark" }) }));
+vi.mock("../state/use-atom-query-runner", () => ({ useAtomQueryRunner: () => vi.fn() }));
+vi.mock("../state/use-atom-command", () => ({ useAtomCommand: () => vi.fn() }));
+vi.mock("../state/session", async (importOriginal) => ({
+ ...(await importOriginal()),
+ usePreparedConnection: () => ({ _tag: "Loading" }),
+}));
+vi.mock("../state/entities", () => ({
+ readThreadShell: () => null,
+ useActiveEnvironmentId: () => EnvironmentId.make("env-windows"),
+ useProjects: () => [],
+}));
+vi.mock("../editorPreferences", () => ({ useOpenInPreferredEditor: () => vi.fn() }));
+vi.mock("~/lib/openPullRequestLink", () => ({
+ findProjectForChangeRequest: () => undefined,
+ matchesLinkedPullRequestUrl: () => false,
+ parseChangeRequestUrl: () => null,
+ useOpenChangeRequestLink: () => vi.fn(),
+}));
+
+import ChatMarkdown from "./ChatMarkdown";
+
+const threadRef = {
+ environmentId: EnvironmentId.make("env-windows"),
+ threadId: ThreadId.make("thread-windows"),
+};
+
+function render(markdown: string): string {
+ return renderToStaticMarkup(
+ 
`);
+
+ expect(testState.resources).toEqual([
+ {
+ _tag: "workspace-file",
+ threadId: threadRef.threadId,
+ path: "D:/screens/workspace-image.svg",
+ },
+ ]);
+ expect(html).toContain("https://signed.test/workspace-image.svg");
+ });
+
+ it("uses a static placeholder while a signed asset URL loads", () => {
+ testState.assetState = "loading";
+
+ const html = render("");
+
+ expect(html).toContain('aria-label="Loading image"');
+ expect(html).not.toContain("animate-pulse");
+ });
+
+ it("never passes a workspace source to a raw image when thread context is unavailable", () => {
+ const html = renderWithoutThread(
+ "",
+ );
+
+ expect(testState.resources).toEqual([]);
+ expect(html).toContain("Image unavailable");
+ expect(html).not.toContain("file://");
+ });
+
+ it("blocks unsupported image schemes instead of passing them to a raw image", () => {
+ const html = render("");
+
+ expect(testState.resources).toEqual([]);
+ expect(html).toContain("Image unavailable");
+ expect(html).not.toContain("content://");
+ });
+
+ it("keeps remote images directly loadable", () => {
+ const html = render("");
+
+ expect(testState.resources).toEqual([]);
+ expect(html).toContain('src="https://example.com/image.png"');
+ expect(html).toContain("max-w-[min(100%,30rem)]");
+ expect(html).toContain("max-h-[30rem]");
+ expect(html).not.toContain("Image unavailable");
+ });
+});
diff --git a/apps/web/src/components/ChatView.logic.test.ts b/apps/web/src/components/ChatView.logic.test.ts
index 1f858b387a83..1d0e8b0eedc5 100644
--- a/apps/web/src/components/ChatView.logic.test.ts
+++ b/apps/web/src/components/ChatView.logic.test.ts
@@ -28,13 +28,18 @@ import {
resolvedSteeredMessageIds,
reconcileMountedTerminalThreadIds,
reconcileRetainedMountedThreadIds,
+ resolveBackgroundDraftWorkspaceOptions,
+ resolveDraftPromotionNavigationTarget,
resolveThreadMetadataUpdateForNextTurn,
resolveSendEnvMode,
+ resolveDraftHeroState,
+ resolveServerThreadError,
shouldRenderServerThreadRoute,
shouldTreatServerThreadAsActive,
- resolveServerThreadError,
scheduleEnvironmentReconnectWarning,
startNewThreadForProject,
+ shouldDockDraftHeroForSubmission,
+ shouldReleaseTimelineAnchorForToolActivity,
shouldShowBranchMismatchBanner,
shouldWriteThreadErrorToCurrentServerThread,
} from "./ChatView.logic";
@@ -50,6 +55,148 @@ const projectId = ProjectId.make("project-1");
const threadId = ThreadId.make("thread-1");
const now = "2026-03-29T00:00:00.000Z";
+describe("draft hero submission transition", () => {
+ it("does not dock the composer before a background submission", () => {
+ expect(
+ shouldDockDraftHeroForSubmission({
+ isDraftHeroState: true,
+ activeThreadKey: "environment-local:thread-1",
+ submissionIntent: "background",
+ }),
+ ).toBe(false);
+ });
+
+ it("keeps the composer in the hero layout until navigation after server promotion", () => {
+ expect(
+ resolveDraftHeroState({
+ isLocalDraftThread: false,
+ hasTimelineEntries: true,
+ isWorking: true,
+ draftHeroDockRequested: false,
+ backgroundSubmissionPending: true,
+ }),
+ ).toBe(true);
+ });
+
+ it("does not auto-navigate a background submission after server promotion", () => {
+ expect(
+ resolveDraftPromotionNavigationTarget({
+ serverThreadRef: { environmentId, threadId },
+ serverThreadStarted: true,
+ backgroundSubmissionPending: true,
+ }),
+ ).toBeNull();
+ });
+});
+
+describe("shouldReleaseTimelineAnchorForToolActivity", () => {
+ const activeTurnId = TurnId.make("active-turn");
+ const anchorMessageId = MessageId.make("anchored-message");
+ const activeToolEntry = {
+ id: "tool-entry",
+ kind: "work" as const,
+ createdAt: now,
+ entry: {
+ id: "active-tool",
+ createdAt: now,
+ turnId: activeTurnId,
+ label: "Run command",
+ tone: "tool" as const,
+ command: "git status",
+ },
+ };
+
+ it("releases the send anchor for tool activity in the active turn", () => {
+ expect(
+ shouldReleaseTimelineAnchorForToolActivity({
+ anchorMessageId,
+ liveFollowEnabled: true,
+ runningTurnId: activeTurnId,
+ timelineEntries: [activeToolEntry],
+ }),
+ ).toBe(true);
+ });
+
+ it("keeps the anchor while the user reads history", () => {
+ expect(
+ shouldReleaseTimelineAnchorForToolActivity({
+ anchorMessageId,
+ liveFollowEnabled: false,
+ runningTurnId: activeTurnId,
+ timelineEntries: [activeToolEntry],
+ }),
+ ).toBe(false);
+ });
+
+ it("ignores tool activity from earlier turns", () => {
+ expect(
+ shouldReleaseTimelineAnchorForToolActivity({
+ anchorMessageId,
+ liveFollowEnabled: true,
+ runningTurnId: activeTurnId,
+ timelineEntries: [
+ {
+ ...activeToolEntry,
+ entry: {
+ ...activeToolEntry.entry,
+ turnId: TurnId.make("previous-turn"),
+ },
+ },
+ ],
+ }),
+ ).toBe(false);
+ });
+
+ it("ignores thinking and error rows without tool activity", () => {
+ expect(
+ shouldReleaseTimelineAnchorForToolActivity({
+ anchorMessageId,
+ liveFollowEnabled: true,
+ runningTurnId: activeTurnId,
+ timelineEntries: [
+ {
+ ...activeToolEntry,
+ entry: {
+ id: "thinking-entry",
+ createdAt: now,
+ turnId: activeTurnId,
+ label: "Thinking",
+ tone: "thinking",
+ },
+ },
+ {
+ ...activeToolEntry,
+ id: "error-entry",
+ entry: {
+ id: "error-entry",
+ createdAt: now,
+ turnId: activeTurnId,
+ label: "Provider error",
+ tone: "error",
+ },
+ },
+ ],
+ }),
+ ).toBe(false);
+ });
+
+ it("does nothing without an anchor or running turn", () => {
+ const input = {
+ anchorMessageId,
+ liveFollowEnabled: true,
+ runningTurnId: activeTurnId,
+ timelineEntries: [activeToolEntry],
+ };
+
+ expect(shouldReleaseTimelineAnchorForToolActivity({ ...input, anchorMessageId: null })).toBe(
+ false,
+ );
+ expect(shouldReleaseTimelineAnchorForToolActivity({ ...input, runningTurnId: null })).toBe(
+ false,
+ );
+ });
+});
+
describe("environment reconnect warning grace", () => {
afterEach(() => vi.useRealTimers());
@@ -445,6 +592,23 @@ describe("resolveSendEnvMode", () => {
});
});
+describe("resolveBackgroundDraftWorkspaceOptions", () => {
+ it("keeps New worktree selected without reusing the launched worktree", () => {
+ expect(
+ resolveBackgroundDraftWorkspaceOptions({
+ envMode: "worktree",
+ branch: "main",
+ startFromOrigin: true,
+ }),
+ ).toEqual({
+ envMode: "worktree",
+ branch: "main",
+ worktreePath: null,
+ startFromOrigin: true,
+ });
+ });
+});
+
describe("branchMismatchKey", () => {
it("builds a key from thread id and both branches", () => {
expect(branchMismatchKey("thread-1", { threadBranch: "feat/a", currentBranch: "feat/b" })).toBe(
@@ -658,6 +822,30 @@ describe("hasServerAcknowledgedLocalDispatch", () => {
).toBe(false);
});
+ it("keeps a follow-up active while its provider session is starting", () => {
+ const localDispatch = createLocalDispatchSnapshot(
+ makeThread({ latestTurn: completedTurn, session: readySession }),
+ );
+
+ expect(
+ hasServerAcknowledgedLocalDispatch({
+ localDispatch,
+ phase: "connecting",
+ latestTurn: completedTurn,
+ latestUserMessageId: MessageId.make("message-followup"),
+ projectedMessageIds: new Set(),
+ session: {
+ ...readySession,
+ status: "starting",
+ updatedAt: "2026-03-29T00:01:00.000Z",
+ },
+ hasPendingApproval: false,
+ hasPendingUserInput: false,
+ threadError: null,
+ }),
+ ).toBe(false);
+ });
+
it("acknowledges a settled newer turn", () => {
const localDispatch = createLocalDispatchSnapshot(
makeThread({ latestTurn: completedTurn, session: readySession }),
diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.ts
index 0ba523d56f3e..b1a2168b7e19 100644
--- a/apps/web/src/components/ChatView.logic.ts
+++ b/apps/web/src/components/ChatView.logic.ts
@@ -22,6 +22,8 @@ import {
type TerminalContextDraft,
} from "../lib/terminalContext";
import type { DraftThreadEnvMode } from "../composerDraftStore";
+import type { ComposerSubmissionIntent } from "../composer-logic";
+import type { TimelineEntry } from "../session-logic";
export const LAST_INVOKED_SCRIPT_BY_PROJECT_KEY = "t3code:last-invoked-script-by-project";
export const MAX_HIDDEN_MOUNTED_TERMINAL_THREADS = 10;
@@ -30,6 +32,72 @@ export const ENVIRONMENT_RECONNECT_WARNING_GRACE_MS = 2_000;
export const LastInvokedScriptByProjectSchema = Schema.Record(ProjectId, Schema.String);
+export function shouldDockDraftHeroForSubmission(input: {
+ isDraftHeroState: boolean;
+ activeThreadKey: string | null;
+ submissionIntent: ComposerSubmissionIntent;
+}): boolean {
+ return (
+ input.submissionIntent === "foreground" &&
+ input.isDraftHeroState &&
+ input.activeThreadKey !== null
+ );
+}
+
+export function shouldReleaseTimelineAnchorForToolActivity(input: {
+ anchorMessageId: MessageId | null;
+ liveFollowEnabled: boolean;
+ runningTurnId: TurnId | null;
+ timelineEntries: ReadonlyArray;
+}): boolean {
+ if (input.anchorMessageId === null || !input.liveFollowEnabled || input.runningTurnId === null) {
+ return false;
+ }
+
+ return input.timelineEntries.some((timelineEntry) => {
+ if (timelineEntry.kind !== "work" || timelineEntry.entry.turnId !== input.runningTurnId) {
+ return false;
+ }
+
+ const entry = timelineEntry.entry;
+ return (
+ entry.tone === "tool" ||
+ entry.itemType !== undefined ||
+ entry.requestKind !== undefined ||
+ (entry.command?.trim().length ?? 0) > 0
+ );
+ });
+}
+
+export function resolveDraftHeroState(input: {
+ isLocalDraftThread: boolean;
+ hasTimelineEntries: boolean;
+ isWorking: boolean;
+ draftHeroDockRequested: boolean;
+ backgroundSubmissionPending: boolean;
+}): boolean {
+ if (input.backgroundSubmissionPending) {
+ return true;
+ }
+ return (
+ input.isLocalDraftThread &&
+ !input.hasTimelineEntries &&
+ !input.isWorking &&
+ !input.draftHeroDockRequested
+ );
+}
+
+export function resolveDraftPromotionNavigationTarget(input: {
+ serverThreadRef: ScopedThreadRef | null;
+ serverThreadStarted: boolean;
+ backgroundSubmissionPending: boolean;
+}): ScopedThreadRef | null {
+ if (input.backgroundSubmissionPending) {
+ return null;
+ }
+ return input.serverThreadStarted ? input.serverThreadRef : null;
+}
+
export function scheduleEnvironmentReconnectWarning(showWarning: () => void): () => void {
const timeoutId = globalThis.setTimeout(showWarning, ENVIRONMENT_RECONNECT_WARNING_GRACE_MS);
return () => globalThis.clearTimeout(timeoutId);
@@ -347,6 +415,24 @@ export function resolveSendEnvMode(input: {
return input.isGitRepo ? input.requestedEnvMode : "local";
}
+export function resolveBackgroundDraftWorkspaceOptions(input: {
+ envMode: DraftThreadEnvMode;
+ branch: string | null;
+ startFromOrigin: boolean;
+}): {
+ envMode: DraftThreadEnvMode;
+ branch: string | null;
+ worktreePath: null;
+ startFromOrigin: boolean;
+} {
+ return {
+ envMode: input.envMode,
+ branch: input.branch,
+ worktreePath: null,
+ startFromOrigin: input.envMode === "worktree" && input.startFromOrigin,
+ };
+}
+
export function cloneComposerImageForRetry(
image: ComposerImageAttachment,
): ComposerImageAttachment {
@@ -588,6 +674,7 @@ export interface LocalDispatchSnapshot {
* that other clients' activity could satisfy.
*/
expectedMessageId: ChatMessage["id"] | null;
+ submissionIntent: ComposerSubmissionIntent;
latestUserMessageId: ChatMessage["id"] | null;
latestTurnTurnId: TurnId | null;
latestTurnRequestedAt: string | null;
@@ -599,7 +686,11 @@ export interface LocalDispatchSnapshot {
export function createLocalDispatchSnapshot(
activeThread: Thread | undefined,
- options?: { preparingWorktree?: boolean; messageId?: ChatMessage["id"] },
+ options?: {
+ preparingWorktree?: boolean;
+ messageId?: ChatMessage["id"];
+ submissionIntent?: ComposerSubmissionIntent;
+ },
): LocalDispatchSnapshot {
const latestTurn = activeThread?.latestTurn ?? null;
const session = activeThread?.session ?? null;
@@ -608,6 +699,7 @@ export function createLocalDispatchSnapshot(
startedAt: new Date().toISOString(),
preparingWorktree: Boolean(options?.preparingWorktree),
expectedMessageId: options?.messageId ?? null,
+ submissionIntent: options?.submissionIntent ?? "foreground",
latestUserMessageId: latestUserMessage?.id ?? null,
latestTurnTurnId: latestTurn?.turnId ?? null,
latestTurnRequestedAt: latestTurn?.requestedAt ?? null,
@@ -635,6 +727,9 @@ export function hasServerAcknowledgedLocalDispatch(input: {
if (input.hasPendingApproval || input.hasPendingUserInput || Boolean(input.threadError)) {
return true;
}
+ if (input.phase === "connecting") {
+ return false;
+ }
const latestTurn = input.latestTurn ?? null;
const session = input.session ?? null;
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 58abd7baa16e..f2b811de03cb 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -26,12 +26,19 @@ import {
connectionStatusTitle,
type EnvironmentConnectionPresentation,
} from "@t3tools/client-runtime/connection";
+import { wasBootstrapThreadDeleted } from "@t3tools/client-runtime/errors";
import {
changeRequestAutoSettles,
effectiveSettled,
effectiveSnoozed,
threadWokeAt,
} from "@t3tools/client-runtime/state/thread-settled";
+import {
+ codexFeedbackMessage,
+ parseCodexFeedbackCommand,
+ submitCodexFeedback,
+ type CodexFeedbackSubmission,
+} from "@t3tools/client-runtime/state/threads";
import {
parseScopedThreadKey,
scopedThreadKey,
@@ -76,6 +83,7 @@ import {
type AtomCommandResult,
} from "@t3tools/client-runtime/state/runtime";
import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
import { AsyncResult } from "effect/unstable/reactivity";
import { isTransportConnectionErrorMessage } from "@t3tools/client-runtime/errors";
import {
@@ -87,6 +95,7 @@ import { readLocalApi } from "../localApi";
import { useDiffPanelStore } from "../diffPanelStore";
import {
collapseExpandedComposerCursor,
+ type ComposerSubmissionIntent,
parseStandaloneComposerSlashCommand,
} from "../composer-logic";
import {
@@ -130,6 +139,7 @@ import {
} from "../types";
import { useTheme } from "../hooks/useTheme";
import { useNewThreadHandler } from "../hooks/useHandleNewThread";
+import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
import { useTurnDiffSummaries } from "../hooks/useTurnDiffSummaries";
import { isCommandPaletteOpen } from "../commandPaletteBus";
import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git";
@@ -181,6 +191,7 @@ import {
CheckCircle2Icon,
ChevronDownIcon,
GitBranchIcon,
+ Minimize2Icon,
PaperclipIcon,
WifiOffIcon,
} from "lucide-react";
@@ -205,13 +216,18 @@ import {
import { useBrowserHistoryStore } from "~/browserHistoryStore";
import { registerFaviconProjectForThread } from "~/browserFaviconStore";
import { getProviderModelCapabilities, resolveSelectableProvider } from "../providerModels";
-import { NO_PROVIDER_MODEL_SELECTION } from "../providerInstances";
+import {
+ applyProviderInstanceSettings,
+ deriveProviderInstanceEntries,
+ NO_PROVIDER_MODEL_SELECTION,
+} from "../providerInstances";
import {
useClientSettings,
useClientSettingsHydrated,
useEnvironmentSettings,
} from "../hooks/useSettings";
import { useNowMinute } from "../hooks/useNowMinute";
+import { useThreadActions } from "../hooks/useThreadActions";
import { resolveAppModelSelectionForInstance } from "../modelSelection";
import { confirmTerminalClose, isTerminalCloseConfirmPending } from "../lib/terminalCloseConfirm";
import { getTerminalFocusOwner } from "../lib/terminalFocus";
@@ -226,10 +242,15 @@ import {
selectProjectGroupingSettings,
} from "../logicalProject";
import { buildPhysicalToLogicalProjectKeyMap } from "../sidebarProjectGrouping";
-import { buildDraftThreadRouteParams } from "../threadRoutes";
+import { buildDraftThreadRouteParams, buildThreadRouteParams } from "../threadRoutes";
import {
+ beginBackgroundDraftSubmissionByRef,
+ clearBackgroundDraftSubmissionByRef,
+ composerDraftHasUserContent,
type ComposerImageAttachment,
type DraftThreadEnvMode,
+ finalizePromotedDraftThreadByRef,
+ markPromotedDraftThreadByRef,
useComposerDraftStore,
type DraftId,
} from "../composerDraftStore";
@@ -309,9 +330,17 @@ import {
import {
resolveDisplayedThreadPr,
threadChangeRequestSnapshotsAtom,
+ useLinkedThreadPullRequest,
} from "./ThreadStatusIndicators";
import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/ComposerBannerStack";
import { QueuedMessageChips, type DisplayQueuedMessage } from "./chat/QueuedMessageChips";
+import {
+ hasAvailableClaudeCompactionProvider,
+ hasDismissedResumeCompaction,
+ shouldOfferResumeCompaction,
+} from "./chat/ContextWindowMeter.logic";
+import { deriveLatestContextWindowSnapshot, formatContextWindowTokens } from "../lib/contextWindow";
+import { ThreadSyncStatusPill } from "./chat/ThreadSyncStatusPill";
import {
DRAFT_HERO_TRANSITION_ANIMATION_ID,
DRAFT_HERO_TRANSITION_DURATION_MS,
@@ -335,6 +364,8 @@ import {
scheduleEnvironmentReconnectWarning,
hasServerAcknowledgedLocalDispatch,
isBranchMismatchDismissedForSession,
+ shouldDockDraftHeroForSubmission,
+ shouldReleaseTimelineAnchorForToolActivity,
shouldShowBranchMismatchBanner,
getStartedThreadModelChangeBlockReason,
LAST_INVOKED_SCRIPT_BY_PROJECT_KEY,
@@ -345,6 +376,8 @@ import {
deriveLockedProvider,
readFileAsDataUrl,
reconcileMountedTerminalThreadIds,
+ resolveBackgroundDraftWorkspaceOptions,
+ resolveDraftHeroState,
resolveThreadMetadataUpdateForNextTurn,
resolveSendEnvMode,
revokeBlobPreviewUrl,
@@ -357,6 +390,12 @@ import {
} from "./ChatView.logic";
import { useLocalStorage } from "~/hooks/useLocalStorage";
import { useComposerHandleContext } from "../composerHandleContext";
+import {
+ awaitAttachmentUploads,
+ getUploadedAttachments,
+ releaseAttachmentUploads,
+ startAttachmentUpload,
+} from "../lib/attachmentUploadQueue";
import { sanitizeThreadErrorMessage } from "~/rpc/transportError";
import { RightPanelSheet } from "./RightPanelSheet";
import { previewEnvironment } from "../state/preview";
@@ -646,14 +685,22 @@ function useLocalDispatchState(input: {
);
const activeLocalDispatch = serverAcknowledgedLocalDispatch ? null : localDispatch;
const beginLocalDispatch = useCallback(
- (options?: { preparingWorktree?: boolean; messageId?: MessageId }) => {
+ (options?: {
+ preparingWorktree?: boolean;
+ messageId?: MessageId;
+ submissionIntent?: ComposerSubmissionIntent;
+ }) => {
const preparingWorktree = Boolean(options?.preparingWorktree);
setLocalDispatch((current) => {
const active = serverAcknowledgedLocalDispatch ? null : current;
if (active) {
- return active.preparingWorktree === preparingWorktree
+ const submissionIntent = options?.submissionIntent ?? active.submissionIntent;
+ const expectedMessageId = options?.messageId ?? active.expectedMessageId;
+ return active.preparingWorktree === preparingWorktree &&
+ active.submissionIntent === submissionIntent &&
+ active.expectedMessageId === expectedMessageId
? active
- : { ...active, preparingWorktree };
+ : { ...active, preparingWorktree, submissionIntent, expectedMessageId };
}
return createLocalDispatchSnapshot(input.activeThread, options);
});
@@ -668,6 +715,7 @@ function useLocalDispatchState(input: {
latestUserMessageAt: latestUserMessage?.createdAt ?? null,
isPreparingWorktree: activeLocalDispatch?.preparingWorktree ?? false,
isSendBusy: activeLocalDispatch !== null,
+ backgroundSubmissionPending: localDispatch?.submissionIntent === "background",
};
}
@@ -1255,6 +1303,20 @@ function chatActionErrorMessage(error: unknown): string {
return error instanceof Error ? error.message : "An error occurred.";
}
+/**
+ * Drops the send-time anchored end space. That space is what holds a sent
+ * message near the top while its turn streams, and it keeps LegendList's
+ * maintainScrollAtEnd switched off for as long as it is installed — ChatView
+ * drives the streaming scrolls itself, but only in "anchoring-new-turn" mode.
+ * So every return to the live edge has to release the anchor too, otherwise the
+ * timeline settles into "following-end" with nothing following anything.
+ */
+function releaseChatTimelineAnchor(
+ current: T,
+): T {
+ return current.messageId === null ? current : { ...current, messageId: null };
+}
+
function ChatViewContent(props: ChatViewProps) {
const {
environmentId,
@@ -1267,6 +1329,8 @@ function ChatViewContent(props: ChatViewProps) {
} = props;
const threadDetailLoading = threadSyncPhase === "loading";
const draftId = routeKind === "draft" ? props.draftId : null;
+ const handleNewThread = useNewThreadHandler();
+ const { settleThread } = useThreadActions();
const routeThreadRef = useMemo(
() => scopeThreadRef(environmentId, threadId),
[environmentId, threadId],
@@ -1299,6 +1363,9 @@ function ChatViewContent(props: ChatViewProps) {
reportFailure: false,
});
const startThreadTurn = useAtomCommand(threadEnvironment.startTurn, { reportFailure: false });
+ const uploadThreadFeedback = useAtomCommand(threadEnvironment.uploadFeedback, {
+ reportFailure: false,
+ });
const interruptThreadTurn = useAtomCommand(threadEnvironment.interruptTurn, {
reportFailure: false,
});
@@ -1322,7 +1389,6 @@ function ChatViewContent(props: ChatViewProps) {
const { environments } = useEnvironments();
const primaryEnvironment = usePrimaryEnvironment();
const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, { reportFailure: false });
- const handleNewThread = useNewThreadHandler();
const environmentById = useMemo(
() => new Map(environments.map((environment) => [environment.environmentId, environment])),
[environments],
@@ -1388,6 +1454,9 @@ function ChatViewContent(props: ChatViewProps) {
const composerActiveProvider = useComposerDraftStore(
(store) => store.getComposerDraft(composerDraftTarget)?.activeProvider ?? null,
);
+ const composerHasUnsentContent = useComposerDraftStore((store) =>
+ composerDraftHasUserContent(store.getComposerDraft(composerDraftTarget)),
+ );
const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
const addComposerDraftImages = useComposerDraftStore((store) => store.addImages);
const setComposerDraftTerminalContexts = useComposerDraftStore(
@@ -1425,6 +1494,16 @@ function ChatViewContent(props: ChatViewProps) {
const [hasUnreadTimelineActivity, setHasUnreadTimelineActivity] = useState(false);
const [expandedImage, setExpandedImage] = useState(null);
const [optimisticUserMessages, setOptimisticUserMessages] = useState([]);
+ const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
+ Record>
+ >({});
+ const feedbackSubmissions = useMemo(
+ () => feedbackSubmissionsByThreadKey[routeThreadKey] ?? [],
+ [feedbackSubmissionsByThreadKey, routeThreadKey],
+ );
+ const feedbackUploading = feedbackSubmissions.some(
+ (submission) => submission.status === "uploading",
+ );
const optimisticUserMessagesRef = useRef(optimisticUserMessages);
optimisticUserMessagesRef.current = optimisticUserMessages;
// Optimistic sends the server will hold in the steering queue. They are the
@@ -1505,6 +1584,7 @@ function ChatViewContent(props: ChatViewProps) {
const attachmentPreviewPromotionInFlightByMessageIdRef = useRef>({});
const sendInFlightRef = useRef(false);
const queuedTurnDrainInFlightRef = useRef(false);
+ const feedbackUploadsInFlightRef = useRef(new Set());
const terminalUiOpenByThreadRef = useRef>({});
useLayoutEffect(() => {
@@ -1812,6 +1892,9 @@ function ChatViewContent(props: ChatViewProps) {
return openTerminalThreadKeys.filter((nextThreadKey) => existingThreadKeys.has(nextThreadKey));
}, [draftThreadKeys, openTerminalThreadKeys, serverThreadKeys]);
const activeLatestTurn = activeThread?.latestTurn ?? null;
+ const activeRunningTurnId =
+ (activeThread?.session?.status === "running" ? activeThread.session.activeTurnId : null) ??
+ (activeLatestTurn?.state === "running" ? activeLatestTurn.turnId : null);
// Reading a finished thread clears the sidebar's Done badge. The visit is
// stamped at the turn's completion time — not now/updatedAt — so it clears
// exactly the completion the user is looking at: a wake or completion that
@@ -2207,6 +2290,10 @@ function ChatViewContent(props: ChatViewProps) {
: (primaryEnvironment?.serverConfig ?? null);
const pullRequestsCapabilityKnown = serverConfig !== null;
const supportsPullRequests = serverConfig?.environment.capabilities.pullRequests === true;
+ const attachmentEnvironmentConfig = environmentById.get(environmentId)?.serverConfig ?? null;
+ const attachmentUploadsCapabilityKnown = attachmentEnvironmentConfig !== null;
+ const supportsAttachmentUploads =
+ attachmentEnvironmentConfig?.environment.capabilities.attachmentUploads === true;
const versionMismatch = resolveServerConfigVersionMismatch(serverConfig);
const versionMismatchDismissKey =
versionMismatch && activeThread
@@ -2402,6 +2489,10 @@ function ChatViewContent(props: ChatViewProps) {
const phase = derivePhase(activeThread?.session ?? null);
const threadActivities = activeThread?.activities ?? EMPTY_ACTIVITIES;
+ const activeContextWindow = useMemo(
+ () => deriveLatestContextWindowSnapshot(threadActivities),
+ [threadActivities],
+ );
const workLogEntries = useMemo(() => deriveWorkLogEntries(threadActivities), [threadActivities]);
const turnPlans = useMemo(() => deriveTurnPlans(threadActivities), [threadActivities]);
// Native subagent fold: memoized by activity-list identity, shared by the
@@ -2499,6 +2590,7 @@ function ChatViewContent(props: ChatViewProps) {
latestUserMessageAt,
isPreparingWorktree,
isSendBusy,
+ backgroundSubmissionPending,
} = useLocalDispatchState({
activeThread,
activeLatestTurn,
@@ -2758,12 +2850,20 @@ function ChatViewContent(props: ChatViewProps) {
return changed ? { ...message, attachments } : message;
});
- if (optimisticUserMessages.length === 0) {
+ const localMessages = [
+ ...optimisticUserMessages,
+ ...feedbackSubmissions.flatMap((submission) =>
+ submission.status === "interrupted"
+ ? []
+ : [codexFeedbackMessage(submission), codexFeedbackMessage(submission, "assistant")],
+ ),
+ ];
+ if (localMessages.length === 0) {
return serverMessagesWithPreviewHandoff;
}
const serverIds = new Set(serverMessagesWithPreviewHandoff.map((message) => message.id));
// Queue-bound sends render as chips above the composer, never as rows.
- const pendingMessages = optimisticUserMessages.filter(
+ const pendingMessages = localMessages.filter(
(message) => !serverIds.has(message.id) && !optimisticQueuedMessageIds.has(message.id),
);
if (pendingMessages.length === 0) {
@@ -2773,6 +2873,7 @@ function ChatViewContent(props: ChatViewProps) {
}, [
attachmentPreviewHandoffByMessageId,
displayServerMessages,
+ feedbackSubmissions,
optimisticQueuedMessageIds,
optimisticUserMessages,
]);
@@ -2831,8 +2932,13 @@ function ChatViewContent(props: ChatViewProps) {
const [dockedDraftHeroThreadKey, setDockedDraftHeroThreadKey] = useState(null);
const draftHeroDockRequested =
activeThreadKey !== null && dockedDraftHeroThreadKey === activeThreadKey;
- const isDraftHeroState =
- isLocalDraftThread && timelineEntries.length === 0 && !isWorking && !draftHeroDockRequested;
+ const isDraftHeroState = resolveDraftHeroState({
+ isLocalDraftThread,
+ hasTimelineEntries: timelineEntries.length > 0,
+ isWorking,
+ draftHeroDockRequested,
+ backgroundSubmissionPending,
+ });
const [
attachDraftHeroTransitionGroupRef,
attachDraftHeroComposerAnchorRef,
@@ -2911,6 +3017,29 @@ function ChatViewContent(props: ChatViewProps) {
activeThread?.modelSelection.instanceId ??
activeProject?.defaultModelSelection?.instanceId ??
null;
+ const compactionProviderAvailable = useMemo(
+ () =>
+ hasAvailableClaudeCompactionProvider({
+ providers: applyProviderInstanceSettings(
+ deriveProviderInstanceEntries(providerStatuses),
+ settings,
+ ),
+ instanceId: activeProviderInstanceId,
+ lockedInstanceId: lockedProvider
+ ? (activeThread?.session?.providerInstanceId ??
+ activeThread?.modelSelection.instanceId ??
+ null)
+ : null,
+ }),
+ [
+ activeProviderInstanceId,
+ activeThread?.modelSelection.instanceId,
+ activeThread?.session?.providerInstanceId,
+ lockedProvider,
+ providerStatuses,
+ settings,
+ ],
+ );
const activeProviderStatus = useMemo(() => {
if (activeProviderInstanceId) {
return (
@@ -2920,6 +3049,25 @@ function ChatViewContent(props: ChatViewProps) {
const defaultInstanceId = defaultInstanceIdForDriver(selectedProvider);
return providerStatuses.find((status) => status.instanceId === defaultInstanceId) ?? null;
}, [activeProviderInstanceId, providerStatuses, selectedProvider]);
+ const [resumeCompactionPermanentlyDismissed, setResumeCompactionPermanentlyDismissed] =
+ useLocalStorage(
+ `t3code:resume-compaction-dismissed:${environmentId}:${activeProviderInstanceId ?? "claudeAgent"}`,
+ false,
+ Schema.Boolean,
+ );
+ const nativeResumeCompactionDismissed = useMemo(
+ () => hasDismissedResumeCompaction(threadActivities),
+ [threadActivities],
+ );
+ useEffect(() => {
+ if (nativeResumeCompactionDismissed && !resumeCompactionPermanentlyDismissed) {
+ setResumeCompactionPermanentlyDismissed(true);
+ }
+ }, [
+ nativeResumeCompactionDismissed,
+ resumeCompactionPermanentlyDismissed,
+ setResumeCompactionPermanentlyDismissed,
+ ]);
const providerStatusBannerKey = getProviderStatusBannerKey(activeProviderStatus);
const [dismissedProviderStatusBannerKey, setDismissedProviderStatusBannerKey] = useState<
string | null
@@ -3553,25 +3701,50 @@ function ChatViewContent(props: ChatViewProps) {
);
// The thread's own change request, placed against the project it belongs to. Without a
// project there is nothing to resolve it against, so the caller falls back to the browser.
- const threadRepository = activeProject?.repositoryIdentity?.displayName ?? null;
+ const linkedThreadPullRequest = activeThread?.linkedPullRequest ?? null;
+ const activeProjectRepository = activeProject?.repositoryIdentity?.displayName ?? null;
+ const threadRepository = linkedThreadPullRequest?.repository ?? activeProjectRepository;
const openThreadPullRequest = useCallback(
(number: number, repository: string | null = threadRepository) => {
- const selectedRepository = repository ?? threadRepository;
+ if (!supportsPullRequests || !activeThreadRef) {
+ return;
+ }
+ const projectId = linkedThreadPullRequest?.projectId ?? activeProject?.id;
+ const selectedRepository =
+ repository ?? linkedThreadPullRequest?.repository ?? activeProjectRepository;
+ if (projectId === undefined || selectedRepository === null) return;
+ useRightPanelStore.getState().openPullRequest(activeThreadRef, {
+ projectId,
+ repository: selectedRepository,
+ number,
+ });
+ },
+ [
+ activeProject,
+ activeProjectRepository,
+ activeThreadRef,
+ linkedThreadPullRequest,
+ supportsPullRequests,
+ threadRepository,
+ ],
+ );
+ const openProjectPullRequest = useCallback(
+ (number: number) => {
if (
!supportsPullRequests ||
!activeThreadRef ||
!activeProject ||
- selectedRepository === null
+ activeProjectRepository === null
) {
return;
}
useRightPanelStore.getState().openPullRequest(activeThreadRef, {
projectId: activeProject.id,
- repository: selectedRepository,
+ repository: activeProjectRepository,
number,
});
},
- [activeProject, activeThreadRef, supportsPullRequests, threadRepository],
+ [activeProject, activeProjectRepository, activeThreadRef, supportsPullRequests],
);
const togglePreviewPanel = useCallback(() => {
if (!activeThreadRef || !isPreviewSupportedInRuntime()) return;
@@ -4053,17 +4226,39 @@ function ChatViewContent(props: ChatViewProps) {
liveFollowUserScrollGenerationRef.current = anchorUserScrollGenerationRef.current;
setTimelineLiveFollowEnabled(true);
pendingTimelineAnchorRef.current = null;
+ positionedTimelineAnchorRef.current = null;
+ settledTimelineAnchorRef.current = null;
activeTimelineAnchorIndexRef.current = null;
showScrollDebouncer.current.cancel();
setShowScrollToBottom(false);
setHasUnreadTimelineActivity(false);
- setTimelineAnchor((current) =>
- current.messageId === null ? current : { ...current, messageId: null },
- );
+ setTimelineAnchor(releaseChatTimelineAnchor);
requestAnimationFrame(() => {
void legendListRef.current?.scrollToEnd?.({ animated });
});
}, []);
+ useLayoutEffect(() => {
+ if (timelineScrollModeRef.current !== "anchoring-new-turn") {
+ return;
+ }
+
+ if (
+ shouldReleaseTimelineAnchorForToolActivity({
+ anchorMessageId: timelineAnchorMessageId,
+ liveFollowEnabled: timelineLiveFollowEnabled,
+ runningTurnId: activeRunningTurnId,
+ timelineEntries,
+ })
+ ) {
+ scrollToEnd();
+ }
+ }, [
+ activeRunningTurnId,
+ scrollToEnd,
+ timelineAnchorMessageId,
+ timelineEntries,
+ timelineLiveFollowEnabled,
+ ]);
useEffect(() => {
let removeListeners: (() => void) | null = null;
let frame: number | null = null;
@@ -4234,6 +4429,11 @@ function ChatViewContent(props: ChatViewProps) {
timelineScrollModeRef.current = "following-end";
liveFollowUserScrollGenerationRef.current = anchorUserScrollGenerationRef.current;
setTimelineLiveFollowEnabled(true);
+ // Reachable only once manual navigation has already broken follow, so
+ // the anchored turn framing is over: the user scrolled back to the live
+ // edge and expects the stream to stick to it again, exactly like the
+ // scroll-to-bottom pill.
+ setTimelineAnchor(releaseChatTimelineAnchor);
showScrollDebouncer.current.cancel();
setShowScrollToBottom(false);
setHasUnreadTimelineActivity(false);
@@ -4551,11 +4751,17 @@ function ChatViewContent(props: ChatViewProps) {
: null;
const autoSettleAfterDays = useClientSettings((settings) => settings.sidebarAutoSettleAfterDays);
const autoSettleOnMerge = useClientSettings((settings) => settings.sidebarAutoSettleOnMerge);
+ const linkedPullRequestStatus = useLinkedThreadPullRequest(
+ activeThreadRef?.environmentId ?? null,
+ linkedThreadPullRequest,
+ );
const activeThreadPr = resolveDisplayedThreadPr({
threadBranch: activeThread?.branch ?? null,
gitStatus: gitStatusQuery.data ?? null,
snapshot: activeThreadKey ? changeRequestSnapshotByKey.get(activeThreadKey) : undefined,
retainTerminalOnBranchMismatch: activeThread?.worktreePath === null,
+ linkedPullRequest: linkedThreadPullRequest,
+ linkedPullRequestStatus,
});
// The right panel offers the thread's own change request, so it can only offer it once the
// branch has one; until then the picker says so rather than opening an empty panel.
@@ -4731,18 +4937,6 @@ function ChatViewContent(props: ChatViewProps) {
// Dismissal lives in a module-level set (survives remounts); this tick just
// forces a re-render so the banner leaves immediately.
const [, setBranchMismatchDismissTick] = useState(0);
- const composerHasDraftContent = useComposerDraftStore((store) => {
- const draft = store.getComposerDraft(composerDraftTarget);
- return Boolean(
- draft &&
- (draft.prompt.trim().length > 0 ||
- draft.images.length > 0 ||
- draft.terminalContexts.length > 0 ||
- draft.elementContexts.length > 0 ||
- draft.previewAnnotations.length > 0 ||
- draft.reviewComments.length > 0),
- );
- });
const activeBranchMismatchKey = branchMismatchKey(
activeThread?.id ?? null,
localCheckoutBranchMismatch,
@@ -4750,7 +4944,7 @@ function ChatViewContent(props: ChatViewProps) {
const showBranchMismatchBanner = shouldShowBranchMismatchBanner({
hasMismatch: localCheckoutBranchMismatch !== null,
isDismissed: isBranchMismatchDismissedForSession(activeBranchMismatchKey),
- composerHasContent: composerHasDraftContent,
+ composerHasContent: composerHasUnsentContent,
wasShownForCurrentMismatch:
revealedBranchMismatchKey !== null && revealedBranchMismatchKey === activeBranchMismatchKey,
});
@@ -4974,6 +5168,107 @@ function ChatViewContent(props: ChatViewProps) {
isUnsnoozing,
isUnsettling,
]);
+ // Session-scoped dismissals, one key per (thread, snapshot). A set rather
+ // than a single slot so dismissing the banner on one thread does not
+ // resurface it on another thread dismissed earlier.
+ const [dismissedResumeCompactionKeys, setDismissedResumeCompactionKeys] = useState<
+ ReadonlySet
+ >(new Set());
+ const resumeCompactionKey =
+ activeThread && activeContextWindow
+ ? `${activeThread.id}:${activeContextWindow.updatedAt}`
+ : null;
+ const compactDisabled =
+ !activeThread ||
+ !activeProject ||
+ !isServerThread ||
+ selectedProvider !== "claudeAgent" ||
+ !compactionProviderAvailable ||
+ isWorking ||
+ threadDetailLoading ||
+ isPreparingWorktree ||
+ activeEnvironmentUnavailable ||
+ feedbackUploading ||
+ pendingApprovals.length > 0 ||
+ pendingUserInputs.length > 0 ||
+ showPlanFollowUpPrompt ||
+ composerHasUnsentContent;
+ const compactDisabledReason = compactDisabled
+ ? composerHasUnsentContent
+ ? "Send or clear your draft before compacting"
+ : !activeProject
+ ? "Choose a project before compacting"
+ : !compactionProviderAvailable
+ ? "Enable a Claude provider before compacting"
+ : "Compacting is unavailable right now"
+ : null;
+ const resumeCompactionBannerItem = useMemo(() => {
+ if (
+ !activeThread ||
+ !activeContextWindow ||
+ resumeCompactionKey === null ||
+ dismissedResumeCompactionKeys.has(resumeCompactionKey) ||
+ resumeCompactionPermanentlyDismissed ||
+ nativeResumeCompactionDismissed ||
+ pendingUserInputs.length > 0 ||
+ phase === "running" ||
+ !shouldOfferResumeCompaction({
+ provider: selectedProvider,
+ usedTokens: activeContextWindow.usedTokens,
+ updatedAt: activeContextWindow.updatedAt,
+ now: `${nowMinute}:00.000Z`,
+ })
+ ) {
+ return null;
+ }
+
+ const dismiss = () =>
+ setDismissedResumeCompactionKeys((keys) => new Set(keys).add(resumeCompactionKey));
+ const compactAction = (
+
+ );
+ return {
+ id: `resume-compaction:${resumeCompactionKey}`,
+ variant: "info",
+ icon:
+ {compactAction}} />
+ {compactDisabledReason}
+
+ ) : (
+ compactAction
+ ),
+ dismissLabel: "Keep full history",
+ onDismiss: dismiss,
+ };
+ }, [
+ activeContextWindow,
+ activeThread,
+ compactDisabled,
+ compactDisabledReason,
+ composerRef,
+ dismissedResumeCompactionKeys,
+ nativeResumeCompactionDismissed,
+ nowMinute,
+ pendingUserInputs.length,
+ phase,
+ resumeCompactionKey,
+ resumeCompactionPermanentlyDismissed,
+ selectedProvider,
+ ]);
const handleRestoreThreadBranch = useCallback(() => {
if (gitStatusQuery.data?.hasWorkingTreeChanges) {
setBranchRestoreConfirmOpen(true);
@@ -4988,6 +5283,8 @@ function ChatViewContent(props: ChatViewProps) {
const calmSystemItems = systemComposerBannerItems.filter((item) => !isUrgentSystemItem(item));
const backgroundLivenessItems =
backgroundLivenessBannerItem === null ? [] : [backgroundLivenessBannerItem];
+ const resumeCompactionItems =
+ resumeCompactionBannerItem === null ? [] : [resumeCompactionBannerItem];
const wokeThreadItems = wokeThreadBannerItem === null ? [] : [wokeThreadBannerItem];
const parkedThreadItems = parkedThreadBannerItem === null ? [] : [parkedThreadBannerItem];
if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) {
@@ -4995,6 +5292,7 @@ function ChatViewContent(props: ChatViewProps) {
...urgentSystemItems,
...backgroundLivenessItems,
...calmSystemItems,
+ ...resumeCompactionItems,
...wokeThreadItems,
...parkedThreadItems,
];
@@ -5003,6 +5301,7 @@ function ChatViewContent(props: ChatViewProps) {
...urgentSystemItems,
...backgroundLivenessItems,
...calmSystemItems,
+ ...resumeCompactionItems,
...wokeThreadItems,
{
id: `branch-mismatch:${activeBranchMismatchKey}`,
@@ -5052,6 +5351,7 @@ function ChatViewContent(props: ChatViewProps) {
isRestoringThreadBranch,
localCheckoutBranchMismatch,
parkedThreadBannerItem,
+ resumeCompactionBannerItem,
showBranchMismatchBanner,
systemComposerBannerItems,
wokeThreadBannerItem,
@@ -5191,6 +5491,29 @@ function ChatViewContent(props: ChatViewProps) {
});
if (!command) return;
+ if (command === "thread.settle") {
+ event.preventDefault();
+ event.stopPropagation();
+ if (!isServerThread || !activeThreadRef || !supportsSettlement) return;
+ if (activeThreadSettled) {
+ void handleUnsettleActiveThread();
+ return;
+ }
+
+ void settleThread(activeThreadRef).then((result) => {
+ if (result._tag !== "Failure" || isAtomCommandInterrupted(result)) return;
+ const error = squashAtomCommandFailure(result);
+ toastManager.add(
+ stackedThreadToast({
+ type: "error",
+ title: "Failed to settle thread",
+ description: error instanceof Error ? error.message : "An error occurred.",
+ }),
+ );
+ });
+ return;
+ }
+
if (command === "terminal.toggle") {
event.preventDefault();
event.stopPropagation();
@@ -5294,6 +5617,8 @@ function ChatViewContent(props: ChatViewProps) {
activeProject,
activeRightPanelSurface,
addTerminalSurface,
+ activeThreadRef,
+ activeThreadSettled,
terminalUiState.terminalOpen,
terminalUiState.activeTerminalId,
activeThreadId,
@@ -5305,7 +5630,11 @@ function ChatViewContent(props: ChatViewProps) {
splitTerminal,
splitPanelTerminal,
keybindings,
+ handleUnsettleActiveThread,
+ isServerThread,
onToggleDiff,
+ settleThread,
+ supportsSettlement,
toggleRightPanel,
toggleRightPanelMaximized,
toggleTerminalVisibility,
@@ -5374,6 +5703,7 @@ function ChatViewContent(props: ChatViewProps) {
const onSend = async (
e?: { preventDefault: () => void },
+ submissionIntent: ComposerSubmissionIntent = "foreground",
directAnnotation?: {
annotation: PreviewAnnotationPayload;
image: ComposerImageAttachment | null;
@@ -5396,7 +5726,8 @@ function ChatViewContent(props: ChatViewProps) {
isConnecting ||
activeEnvironmentUnavailable ||
threadDetailLoading ||
- sendInFlightRef.current
+ sendInFlightRef.current ||
+ feedbackUploadsInFlightRef.current.has(routeThreadKey)
) {
notifyDirectAnnotationAttached();
return;
@@ -5471,6 +5802,101 @@ function ChatViewContent(props: ChatViewProps) {
composerPreviewAnnotations.length +
composerReviewComments.length,
});
+ const feedbackCommand =
+ ctxSelectedProvider === "codex" &&
+ composerImages.length === 0 &&
+ sendableComposerTerminalContexts.length === 0 &&
+ composerElementContexts.length === 0 &&
+ composerPreviewAnnotations.length === 0 &&
+ composerReviewComments.length === 0
+ ? parseCodexFeedbackCommand(trimmed)
+ : null;
+ if (feedbackCommand) {
+ if (!isServerThread || activeThread.session === null) {
+ toastManager.add(
+ stackedThreadToast({
+ type: "warning",
+ title: "Start a Codex thread first",
+ description: "Send a message before you submit feedback.",
+ }),
+ );
+ return;
+ }
+ feedbackUploadsInFlightRef.current.add(routeThreadKey);
+ const result = await submitCodexFeedback({
+ submission: {
+ id: newMessageId(),
+ command: trimmed,
+ createdAt: new Date().toISOString(),
+ },
+ clearDraft: () => {
+ promptRef.current = "";
+ clearComposerDraftContent(composerDraftTarget);
+ composerRef.current?.resetCursorState();
+ scrollToEnd();
+ },
+ onUpdate: (submission) => {
+ setFeedbackSubmissionsByThreadKey((current) => {
+ const existing = current[routeThreadKey] ?? [];
+ const found = existing.some((entry) => entry.id === submission.id);
+ return {
+ ...current,
+ [routeThreadKey]: found
+ ? existing.map((entry) => (entry.id === submission.id ? submission : entry))
+ : [...existing, submission],
+ };
+ });
+ },
+ upload: () =>
+ uploadThreadFeedback({
+ environmentId,
+ input: {
+ threadId: activeThread.id,
+ ...feedbackCommand,
+ },
+ }),
+ }).finally(() => {
+ feedbackUploadsInFlightRef.current.delete(routeThreadKey);
+ });
+ if (result._tag === "Failure") {
+ if (!isAtomCommandInterrupted(result)) {
+ toastManager.add(
+ stackedThreadToast({
+ type: "error",
+ title: "Could not send feedback to OpenAI",
+ description: chatActionErrorMessage(squashAtomCommandFailure(result)),
+ }),
+ );
+ }
+ return;
+ }
+ const feedbackId = result.value.feedbackId;
+ toastManager.add(
+ stackedThreadToast({
+ type: "success",
+ title: "Feedback sent to OpenAI",
+ description: `Thread ID: ${feedbackId}`,
+ timeout: 0,
+ actionProps: {
+ children: "Copy ID",
+ onClick: () => {
+ void writeTextToClipboard(feedbackId, "Codex feedback thread ID").catch(
+ (error: unknown) => {
+ toastManager.add(
+ stackedThreadToast({
+ type: "error",
+ title: "Could not copy thread ID",
+ description: chatActionErrorMessage(error),
+ }),
+ );
+ },
+ );
+ },
+ },
+ }),
+ );
+ return;
+ }
if (!directAnnotation && showPlanFollowUpPrompt && activeProposedPlan) {
const followUp = resolvePlanFollowUpSubmission({
draftText: trimmed,
@@ -5596,7 +6022,28 @@ function ChatViewContent(props: ChatViewProps) {
return new Set(current).add(threadIdForSend);
});
}
- if (isDraftHeroState && activeThreadKey) {
+ if (supportsAttachmentUploads && composerImagesSnapshot.length > 0) {
+ for (const image of composerImagesSnapshot) {
+ startAttachmentUpload({ environmentId, image });
+ }
+ await awaitAttachmentUploads(composerImagesSnapshot.map((image) => image.id));
+ if (getUploadedAttachments({ environmentId, images: composerImagesSnapshot }) === null) {
+ sendInFlightRef.current = false;
+ setThreadError(threadIdForSend, "Retry or remove failed image uploads before sending.");
+ return;
+ }
+ }
+
+ const resolvedSubmissionIntent =
+ submissionIntent === "background" && isLocalDraftThread ? "background" : "foreground";
+ if (
+ shouldDockDraftHeroForSubmission({
+ isDraftHeroState,
+ activeThreadKey,
+ submissionIntent: resolvedSubmissionIntent,
+ }) &&
+ activeThreadKey
+ ) {
let resolveDockStarted: (() => void) | undefined;
const dockStarted = new Promise((resolve) => {
resolveDockStarted = resolve;
@@ -5615,19 +6062,29 @@ function ChatViewContent(props: ChatViewProps) {
beginLocalDispatch({
preparingWorktree: Boolean(baseBranchForWorktree),
messageId: messageIdForSend,
+ submissionIntent: resolvedSubmissionIntent,
});
let turnStartSucceeded = false;
try {
const messageCreatedAt = new Date().toISOString();
const turnAttachmentsPromise = Promise.all(
- composerImagesSnapshot.map(async (image) => ({
- type: "image" as const,
- name: image.name,
- mimeType: image.mimeType,
- sizeBytes: image.sizeBytes,
- dataUrl: await readFileAsDataUrl(image.file),
- })),
+ composerImagesSnapshot.map(async (image) => {
+ if (supportsAttachmentUploads) {
+ const uploaded = getUploadedAttachments({ environmentId, images: [image] })?.[0];
+ if (!uploaded) {
+ throw new Error(`Image '${image.name}' did not finish uploading.`);
+ }
+ return uploaded;
+ }
+ return {
+ type: "image" as const,
+ name: image.name,
+ mimeType: image.mimeType,
+ sizeBytes: image.sizeBytes,
+ dataUrl: await readFileAsDataUrl(image.file),
+ };
+ }),
);
const optimisticAttachments = composerImagesSnapshot.map((image) => ({
type: "image" as const,
@@ -5798,6 +6255,18 @@ function ChatViewContent(props: ChatViewProps) {
: {}),
}
: undefined;
+ beginLocalDispatch({
+ preparingWorktree: false,
+ messageId: messageIdForSend,
+ submissionIntent: resolvedSubmissionIntent,
+ });
+ const backgroundThreadRef =
+ resolvedSubmissionIntent === "background"
+ ? scopeThreadRef(activeThread.environmentId, threadIdForSend)
+ : null;
+ if (backgroundThreadRef) {
+ beginBackgroundDraftSubmissionByRef(backgroundThreadRef);
+ }
const queuedTurnInput = {
commandId: newCommandId(),
threadId: threadIdForSend,
@@ -5837,6 +6306,9 @@ function ChatViewContent(props: ChatViewProps) {
inFlightThreadTurnSends.delete(messageIdForSend);
}
if (startResult._tag === "Failure") {
+ if (backgroundThreadRef) {
+ clearBackgroundDraftSubmissionByRef(backgroundThreadRef);
+ }
const error = squashAtomCommandFailure(startResult);
const message = error instanceof Error ? error.message : String(error);
if (outboxPersisted && isTransportConnectionErrorMessage(message)) {
@@ -5855,7 +6327,57 @@ function ChatViewContent(props: ChatViewProps) {
console.warn("[thread-turn-outbox] failed to remove delivered turn", error);
});
turnStartSucceeded = true;
+ if (supportsAttachmentUploads) {
+ releaseAttachmentUploads(composerImagesSnapshot);
+ }
acknowledgeActiveThreadWoke();
+ if (backgroundThreadRef) {
+ markPromotedDraftThreadByRef(backgroundThreadRef);
+ try {
+ const nextDraft = await handleNewThread(
+ scopeProjectRef(activeProject.environmentId, activeProject.id),
+ resolveBackgroundDraftWorkspaceOptions({
+ envMode: sendEnvMode,
+ branch: activeThreadBranch,
+ startFromOrigin,
+ }),
+ );
+ if (nextDraft) {
+ finalizePromotedDraftThreadByRef(backgroundThreadRef);
+ toastManager.add(
+ stackedThreadToast({
+ type: "success",
+ title: "Started in background",
+ timeout: 5_000,
+ actionProps: {
+ children: "Open",
+ onClick: () => {
+ void navigate({
+ to: "/$environmentId/$threadId",
+ params: buildThreadRouteParams(backgroundThreadRef),
+ });
+ },
+ },
+ }),
+ );
+ } else {
+ clearBackgroundDraftSubmissionByRef(backgroundThreadRef);
+ }
+ } catch (error) {
+ clearBackgroundDraftSubmissionByRef(backgroundThreadRef);
+ resetLocalDispatch();
+ toastManager.add(
+ stackedThreadToast({
+ type: "warning",
+ title: "Task started in the background",
+ description:
+ error instanceof Error
+ ? `Could not open a fresh composer: ${error.message}`
+ : "Could not open a fresh composer.",
+ }),
+ );
+ }
+ }
}
}
@@ -5903,6 +6425,20 @@ function ChatViewContent(props: ChatViewProps) {
}
if (!isAtomCommandInterrupted(failure)) {
const error = squashAtomCommandFailure(failure);
+ if (isLocalDraftThread && draftId && wasBootstrapThreadDeleted(error)) {
+ const failedDraftSession = getDraftSession(draftId);
+ if (failedDraftSession?.threadId === threadIdForSend) {
+ setLogicalProjectDraftThreadId(
+ failedDraftSession.logicalProjectKey,
+ scopeProjectRef(failedDraftSession.environmentId, failedDraftSession.projectId),
+ draftId,
+ {
+ threadId: newThreadId(),
+ createdAt: new Date().toISOString(),
+ },
+ );
+ }
+ }
const message = error instanceof Error ? error.message : "Failed to send message.";
if (isIdentityClaimRequiredMessage(message)) {
requestIdentityClaimGate(activeThread.environmentId);
@@ -6833,7 +7369,7 @@ function ChatViewContent(props: ChatViewProps) {
configuredUrls={configuredPreviewUrls}
visible
onSendAnnotation={(annotation, image) => {
- void onSend(undefined, { annotation, image });
+ void onSend(undefined, "foreground", { annotation, image });
}}
/>
@@ -6888,7 +7424,7 @@ function ChatViewContent(props: ChatViewProps) {
context={
isThreadOwnPullRequest(
{
- projectId: activeProject?.id ?? null,
+ projectId: linkedThreadPullRequest?.projectId ?? activeProject?.id ?? null,
repository: threadPullRequestRepository,
number: activeThreadPr?.number ?? null,
},
@@ -6961,9 +7497,9 @@ function ChatViewContent(props: ChatViewProps) {
>
{!rightPanelOpen ? panelLayoutControls : null}
{
+ event.preventDefault();
+ }}
+ onClick={() => {
+ void submitAddProjectCloneFlow();
+ }}
+ />
+ }
+ >
+ {isRemoteProjectPending ? "Working" : remoteProjectButtonLabel}
+
+ Enter
+
+
+ {remoteProjectButtonLabel ?? "Continue"} (Enter)
+
+ ) : isBrowsing ? (
+
+ {
+ event.preventDefault();
+ }}
+ onClick={() => {
+ if (relativePathNeedsActiveProject) {
+ return;
+ }
+ if (isCloneDestinationStep) {
+ void submitAddProjectCloneFlow(resolvedAddProjectPath);
+ } else {
+ void handleAddProject(resolvedAddProjectPath);
+ }
+ }}
+ />
+ }
+ >
+
+ {isCloneDestinationStep && isRemoteProjectPending ? "Cloning" : submitActionLabel}
+
+
+ {hasHighlightedBrowseItem ? `${submitModifierLabel} Enter` : "Enter"}
+
+
+
+ {submitActionLabel} ({addShortcutLabel})
+
+
+ ) : !isSubmenu ? (
+
+ {
+ event.preventDefault();
+ }}
+ onClick={() => {
+ setIncludeArchived((previous) => !previous);
+ }}
+ />
+ }
+ >
+
+
+ {includeArchived
+ ? "Hide archived threads from search"
+ : "Include archived threads in search"}
+
+
+ ) : null;
+
+ const footerActionLabel =
+ addProjectCloneFlow?.step === "repository"
+ ? (remoteProjectButtonLabel ?? "Continue")
+ : !canSubmitBrowsePath || hasHighlightedBrowseItem
+ ? "Select"
+ : undefined;
+
+ const footerTrailing = canOpenProjectFromFileManager ? (
+ {
+ void handleOpenProjectFromFileManager();
+ }}
+ >
+ {`Open in ${fileManagerName}`}
+
+ ) : null;
+
return (
- {
- event.preventDefault();
- }}
- onClick={() => {
- void submitAddProjectCloneFlow();
- }}
- />
- }
- >
- {isRemoteProjectPending ? "Working" : remoteProjectButtonLabel}
-
- Enter
-
-
-
- {remoteProjectButtonLabel ?? "Continue"} (Enter)
-
-
- ) : isBrowsing ? (
-
- {
- event.preventDefault();
- }}
- onClick={() => {
- if (relativePathNeedsActiveProject) {
- return;
- }
- if (isCloneDestinationStep) {
- void submitAddProjectCloneFlow(resolvedAddProjectPath);
- } else {
- void handleAddProject(resolvedAddProjectPath);
- }
- }}
- />
- }
- >
-
- {isCloneDestinationStep && isRemoteProjectPending ? "Cloning" : submitActionLabel}
-
-
- {hasHighlightedBrowseItem ? `${submitModifierLabel} Enter` : "Enter"}
-
-
-
- {submitActionLabel} ({addShortcutLabel})
-
-
- ) : !isSubmenu ? (
-
- {
- event.preventDefault();
- }}
- onClick={() => {
- setIncludeArchived((previous) => !previous);
- }}
- />
- }
- >
-
-
- {includeArchived
- ? "Hide archived threads from search"
- : "Include archived threads in search"}
-
-
- ) : null}
+ {inputAccessory}
{remoteProjectContext ? (
@@ -2576,15 +2594,10 @@ function OpenCommandPaletteDialog(props: {
Navigate
- {addProjectCloneFlow?.step === "repository" ? (
-
- Enter
- {remoteProjectButtonLabel ?? "Continue"}
-
- ) : !canSubmitBrowsePath || hasHighlightedBrowseItem ? (
+ {footerActionLabel ? (
Enter
- Select
+ {footerActionLabel}
) : null}
{isSubmenu ? (
@@ -2598,19 +2611,7 @@ function OpenCommandPaletteDialog(props: {
Close
- {canOpenProjectFromFileManager ? (
-
- ) : null}
+ {footerTrailing}
diff --git a/apps/web/src/components/Icons.tsx b/apps/web/src/components/Icons.tsx
index fa1bbd8df467..1ed1bd3319f8 100644
--- a/apps/web/src/components/Icons.tsx
+++ b/apps/web/src/components/Icons.tsx
@@ -68,23 +68,26 @@ export const JujutsuIcon: Icon = (props) => {
);
};
-export const GitLabIcon: Icon = (props) => (
+export const GitLabIcon = ({
+ monochrome = false,
+ ...props
+}: SVGProps & { readonly monochrome?: boolean }) => (
);
diff --git a/apps/web/src/components/LegacySidebar.tsx b/apps/web/src/components/LegacySidebar.tsx
index 460c6b66e9e5..e2d2394d934a 100644
--- a/apps/web/src/components/LegacySidebar.tsx
+++ b/apps/web/src/components/LegacySidebar.tsx
@@ -35,6 +35,7 @@ import {
terminalStatusFromRunningIds,
ThreadStatusLabel,
ThreadWorktreeIndicator,
+ useLinkedThreadPullRequest,
} from "./ThreadStatusIndicators";
import { ThreadIdentityMark } from "./identity/ParticipantStack";
import {
@@ -95,7 +96,9 @@ import {
import { isDesktopLocalConnectionTarget } from "../connection/desktopLocal";
import { useDesktopLocalBootstraps } from "../connection/useDesktopLocalBootstraps";
import { isElectron } from "../env";
+import { useTerminalFocus } from "../hooks/useTerminalFocus";
import { useOpenPrLink } from "../lib/openPullRequestLink";
+import { releaseProjectDraftUploads } from "../lib/composerDraftUploads";
import { isTerminalFocused } from "../lib/terminalFocus";
import { cn, isMacPlatform } from "../lib/utils";
import {
@@ -573,7 +576,7 @@ export const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThr
const threadProjectCwd = threadProject?.workspaceRoot ?? null;
const gitCwd = thread.worktreePath ?? threadProjectCwd ?? props.projectCwd;
const gitStatus = useEnvironmentQuery(
- thread.branch != null && gitCwd !== null
+ thread.linkedPullRequest == null && thread.branch != null && gitCwd !== null
? vcsEnvironment.listStatus({
environmentId: thread.environmentId,
input: { cwd: gitCwd },
@@ -614,11 +617,18 @@ export const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThr
lastVisitedAt,
},
});
- const pr = resolveThreadPr({
- threadBranch: thread.branch,
- gitStatus: gitStatus.data ?? null,
- });
- const prStatus = prStatusIndicator(pr, gitStatus.data?.sourceControlProvider);
+ const linkedPullRequestStatus = useLinkedThreadPullRequest(
+ thread.environmentId,
+ thread.linkedPullRequest,
+ );
+ const pr =
+ thread.linkedPullRequest == null
+ ? resolveThreadPr({ threadBranch: thread.branch, gitStatus: gitStatus.data ?? null })
+ : (linkedPullRequestStatus?.pr ?? null);
+ const prStatus = prStatusIndicator(
+ pr,
+ linkedPullRequestStatus?.sourceControlProvider ?? gitStatus.data?.sourceControlProvider,
+ );
// Lift PR state so parent hide-settled / shelf classification can auto-settle
// merged/closed PRs (matches Sidebar V2 row reporting).
const onChangeRequestState = useContext(SidebarChangeRequestStateContext);
@@ -1688,6 +1698,7 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec
return result;
}
const draftStore = useComposerDraftStore.getState();
+ releaseProjectDraftUploads(memberProjectRef);
const projectDraftThread = draftStore.getDraftThreadByProjectRef(memberProjectRef);
if (projectDraftThread) {
draftStore.clearDraftThread(projectDraftThread.draftId);
@@ -5134,6 +5145,7 @@ export default function LegacySidebar() {
const setSelectionAnchor = useThreadSelectionStore((s) => s.setAnchor);
const platform = navigator.platform;
const shortcutModifiers = useShortcutModifierState();
+ const terminalFocused = useTerminalFocus();
const { environments } = useEnvironments();
const primaryEnvironmentId = usePrimaryEnvironmentId();
const [storedListMode, setStoredListMode] = useLocalStorage(
@@ -5760,7 +5772,7 @@ export default function LegacySidebar() {
[threadJumpCommandByKey],
);
const sidebarShortcutContext = {
- terminalFocus: false,
+ terminalFocus: terminalFocused,
terminalOpen: routeTerminalOpen,
modelPickerOpen: isModelPickerOpen(),
};
diff --git a/apps/web/src/components/ProviderUpdateLaunchNotification.logic.test.ts b/apps/web/src/components/ProviderUpdateLaunchNotification.logic.test.ts
index 223960f8314d..2ee06a6b6620 100644
--- a/apps/web/src/components/ProviderUpdateLaunchNotification.logic.test.ts
+++ b/apps/web/src/components/ProviderUpdateLaunchNotification.logic.test.ts
@@ -31,6 +31,7 @@ import {
parseWslDistroFromInstanceId,
providerUpdateNotificationKey,
resolveEnvironmentUpdateRowStatus,
+ shouldShowPrimaryProviderUpdateToast,
type LocalEnvironmentProvidersInput,
type LocalEnvironmentUpdateGroup,
type LocalProviderUpdateOutcome,
@@ -325,6 +326,21 @@ describe("provider update launch notification logic", () => {
type: "loading",
title: "Updating provider",
});
+ expect(shouldShowPrimaryProviderUpdateToast(view)).toBe(false);
+ });
+
+ it("keeps the initial prompt and terminal outcomes visible as toasts", () => {
+ expect(
+ shouldShowPrimaryProviderUpdateToast(
+ getProviderUpdateInitialToastView({
+ updateProviders: [updateCandidate({ driver: driver("codex") })],
+ oneClickProviders: [updateCandidate({ driver: driver("codex") })],
+ }),
+ ),
+ ).toBe(true);
+ expect(
+ shouldShowPrimaryProviderUpdateToast(getProviderUpdateRejectedToastView(1, "boom")),
+ ).toBe(true);
});
it("uses server failure state for failed progress", () => {
diff --git a/apps/web/src/components/ProviderUpdateLaunchNotification.logic.ts b/apps/web/src/components/ProviderUpdateLaunchNotification.logic.ts
index 55999d2a31d8..8d8abf73e312 100644
--- a/apps/web/src/components/ProviderUpdateLaunchNotification.logic.ts
+++ b/apps/web/src/components/ProviderUpdateLaunchNotification.logic.ts
@@ -231,6 +231,10 @@ export function getProviderUpdateInitialToastView(input: {
};
}
+export function shouldShowPrimaryProviderUpdateToast(view: ProviderUpdateToastView): boolean {
+ return view.phase !== "running";
+}
+
export function getProviderUpdateRunningToastView(providerCount: number): ProviderUpdateToastView {
return {
phase: "running",
diff --git a/apps/web/src/components/ProviderUpdatePrimaryNotification.tsx b/apps/web/src/components/ProviderUpdatePrimaryNotification.tsx
index 00112ccec198..639f07c38c13 100644
--- a/apps/web/src/components/ProviderUpdatePrimaryNotification.tsx
+++ b/apps/web/src/components/ProviderUpdatePrimaryNotification.tsx
@@ -16,8 +16,8 @@ import {
getProviderUpdateInitialToastView,
getProviderUpdateProgressToastView,
getProviderUpdateRejectedToastView,
- getProviderUpdateRunningToastView,
providerUpdateNotificationKey,
+ shouldShowPrimaryProviderUpdateToast,
type ProviderUpdateToastView,
} from "./ProviderUpdateLaunchNotification.logic";
import { hiddenToastActionProps, stackedThreadToast, toastManager } from "./ui/toast";
@@ -31,7 +31,6 @@ type ActiveProviderUpdateToast =
| {
readonly kind: "update";
readonly key: string;
- readonly toastId: ProviderUpdateToastId;
readonly providerInstanceIds: ReadonlySet;
readonly providerCount: number;
};
@@ -57,20 +56,16 @@ function ProviderUpdateToastIcon({ provider }: { provider: ProviderDriverKind })
);
}
-function updateProviderUpdateToast(input: {
- readonly toastId: ProviderUpdateToastId;
+function addProviderUpdateToast(input: {
readonly view: ProviderUpdateToastView;
- readonly openSettings: () => void;
+ readonly openSettings: (toastId: ProviderUpdateToastId) => void;
}) {
if (input.view.type === "loading" || input.view.type === "success") {
- toastManager.update(input.toastId, {
+ return toastManager.add({
type: input.view.type,
title: input.view.title,
description: input.view.description,
timeout: 0,
- // Base UI merges toast updates and omits `undefined` keys, so `undefined`
- // would leave the prompt's Update button in place. Replace it with a
- // defined empty action so the CTA cannot linger while the update runs.
actionProps: hiddenToastActionProps,
data: {
hideCopyButton: true,
@@ -79,11 +74,10 @@ function updateProviderUpdateToast(input: {
: {}),
},
});
- return;
}
- toastManager.update(
- input.toastId,
+ let toastId!: ProviderUpdateToastId;
+ toastId = toastManager.add(
stackedThreadToast({
type: input.view.type,
title: input.view.title,
@@ -91,7 +85,7 @@ function updateProviderUpdateToast(input: {
timeout: 0,
actionProps: {
children: "Settings",
- onClick: input.openSettings,
+ onClick: () => input.openSettings(toastId),
},
actionVariant: "outline",
data: {
@@ -99,10 +93,7 @@ function updateProviderUpdateToast(input: {
},
}),
);
-}
-
-function isTerminalProviderUpdateToastView(view: ProviderUpdateToastView) {
- return view.phase === "failed" || view.phase === "unchanged" || view.phase === "succeeded";
+ return toastId;
}
/**
@@ -126,10 +117,10 @@ export function ProviderUpdatePrimaryNotification() {
useEffect(() => {
return () => {
const activeToast = activeToastRef.current;
- if (activeToast) {
+ if (activeToast?.kind === "prompt") {
toastManager.close(activeToast.toastId);
- activeToastRef.current = null;
}
+ activeToastRef.current = null;
};
}, []);
@@ -149,10 +140,14 @@ export function ProviderUpdatePrimaryNotification() {
const activeToast = activeToastRef.current;
if (toastId !== undefined) {
toastManager.close(toastId);
- } else if (activeToast) {
+ } else if (activeToast?.kind === "prompt") {
toastManager.close(activeToast.toastId);
}
- if (activeToast && (toastId === undefined || activeToast.toastId === toastId)) {
+ if (
+ activeToast &&
+ (toastId === undefined ||
+ (activeToast.kind === "prompt" && activeToast.toastId === toastId))
+ ) {
activeToastRef.current = null;
}
void navigate({ to: "/settings/providers" });
@@ -173,15 +168,12 @@ export function ProviderUpdatePrimaryNotification() {
providers: activeProviders,
providerCount: activeToast.providerCount,
});
- updateProviderUpdateToast({
- toastId: activeToast.toastId,
- view,
- openSettings: () => openProviderSettings(activeToast.toastId),
- });
-
- if (isTerminalProviderUpdateToastView(view)) {
- activeToastRef.current = null;
+ if (!shouldShowPrimaryProviderUpdateToast(view)) {
+ return;
}
+
+ addProviderUpdateToast({ view, openSettings: openProviderSettings });
+ activeToastRef.current = null;
}, [providers, openProviderSettings]);
useEffect(() => {
@@ -219,19 +211,15 @@ export function ProviderUpdatePrimaryNotification() {
const providerCount = oneClickProviders.length;
const providerInstanceIds = new Set(oneClickProviders.map((provider) => provider.instanceId));
- activeToastRef.current = {
+ const activeUpdate: ActiveProviderUpdateToast = {
kind: "update",
key: notificationKey,
- toastId,
providerInstanceIds,
providerCount,
};
+ activeToastRef.current = activeUpdate;
- updateProviderUpdateToast({
- toastId,
- view: getProviderUpdateRunningToastView(providerCount),
- openSettings,
- });
+ toastManager.close(toastId);
void (async () => {
const results = [];
@@ -248,16 +236,15 @@ export function ProviderUpdatePrimaryNotification() {
}
const activeUpdateToast = activeToastRef.current;
- if (activeUpdateToast?.kind !== "update" || activeUpdateToast.toastId !== toastId) {
+ if (activeUpdateToast !== activeUpdate) {
return;
}
const failedMessage = firstFailedProviderUpdateMessage(results);
if (failedMessage) {
- updateProviderUpdateToast({
- toastId,
+ addProviderUpdateToast({
view: getProviderUpdateRejectedToastView(providerCount, failedMessage),
- openSettings,
+ openSettings: openProviderSettings,
});
activeToastRef.current = null;
return;
@@ -271,13 +258,8 @@ export function ProviderUpdatePrimaryNotification() {
providers: updatedProviderSnapshots,
providerCount,
});
- updateProviderUpdateToast({
- toastId,
- view,
- openSettings,
- });
-
- if (isTerminalProviderUpdateToastView(view)) {
+ if (shouldShowPrimaryProviderUpdateToast(view)) {
+ addProviderUpdateToast({ view, openSettings: openProviderSettings });
activeToastRef.current = null;
}
})();
diff --git a/apps/web/src/components/RightPanelTabs.test.tsx b/apps/web/src/components/RightPanelTabs.test.tsx
index 1812aa10260b..7b0ae9b4c201 100644
--- a/apps/web/src/components/RightPanelTabs.test.tsx
+++ b/apps/web/src/components/RightPanelTabs.test.tsx
@@ -2,7 +2,12 @@ import type { DesktopPreviewFavicon, PreviewSessionSnapshot } from "@t3tools/con
import { renderToStaticMarkup } from "react-dom/server";
import { describe, expect, it } from "vite-plus/test";
-import { RightPanelTabs, surfaceShortcutActionForKey, tabMuteMenuItem } from "./RightPanelTabs";
+import {
+ RightPanelTabs,
+ surfaceShortcutActionForKey,
+ surfaceShortcutTargetsTypingContext,
+ tabMuteMenuItem,
+} from "./RightPanelTabs";
function shortcutEvent(
key: string,
@@ -166,6 +171,33 @@ describe("surface shortcuts", () => {
});
});
+describe("surface shortcut typing contexts", () => {
+ // Selector-aware stub: closest() answers only tokens the combined selector
+ // would actually match, mirroring how the browser resolves it.
+ const makeTarget = (matches: string | null) => ({
+ closest(selectors: string) {
+ if (matches === null || !selectors.includes(matches)) return null;
+ return {};
+ },
+ });
+
+ it("treats form fields and every editable region as typing contexts", () => {
+ expect(surfaceShortcutTargetsTypingContext(makeTarget("input"))).toBe(true);
+ expect(surfaceShortcutTargetsTypingContext(makeTarget("textarea"))).toBe(true);
+ expect(surfaceShortcutTargetsTypingContext(makeTarget("select"))).toBe(true);
+ // The chat composer is a contenteditable that sits empty until a draft
+ // exists; launcher letters claimed from it redirected prompts into shells.
+ // The :not clause sees past contenteditable="false" islands to an editable
+ // host around them, so nested editors stay protected too.
+ expect(surfaceShortcutTargetsTypingContext(makeTarget("[contenteditable]"))).toBe(true);
+ });
+
+ it("claims letters when focus sits outside any editable region", () => {
+ expect(surfaceShortcutTargetsTypingContext(null)).toBe(false);
+ expect(surfaceShortcutTargetsTypingContext(makeTarget(null))).toBe(false);
+ });
+});
+
describe("RightPanelTabs audio indicator", () => {
// A muted tab only shows the indicator while it is actually making sound:
// arming mute on a quiet tab is deliberate and stays invisible until there
diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsx
index f48c9ca07e4c..9d057a3d2980 100644
--- a/apps/web/src/components/RightPanelTabs.tsx
+++ b/apps/web/src/components/RightPanelTabs.tsx
@@ -10,7 +10,6 @@ import {
TerminalSquare,
Volume2,
VolumeOff,
- X,
} from "lucide-react";
import {
type KeyboardEvent as ReactKeyboardEvent,
@@ -33,6 +32,7 @@ import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
import { Kbd } from "~/components/ui/kbd";
import { Menu, MenuItem, MenuPopup, MenuShortcut, MenuTrigger } from "~/components/ui/menu";
import { ScrollArea } from "~/components/ui/scroll-area";
+import { PanelTabCloseButton } from "~/components/ui/panel-tab-close-button";
import { faviconUrlForOrigin } from "~/lib/favicon";
import { useTheme } from "~/hooks/useTheme";
import { COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS } from "~/workspaceTitlebar";
@@ -190,6 +190,23 @@ export function surfaceShortcutActionForKey<
);
}
+/**
+ * A focused editable is a typing context whether or not it has text yet: an
+ * empty chat composer at rest is still where the user's next keystrokes are
+ * meant to land, and claiming launcher letters from it would redirect prompts
+ * into whatever surface opens. The `:not` clause lets `closest` see past
+ * non-editable islands (`contenteditable="false"`) to an editable host around
+ * them, matching ComposerPendingUserInputPanel's typing guard.
+ */
+export function surfaceShortcutTargetsTypingContext(
+ target: { closest(selectors: string): unknown } | null,
+): boolean {
+ return (
+ target?.closest('input, textarea, select, [contenteditable]:not([contenteditable="false"])') !=
+ null
+ );
+}
+
function DisabledReasonTooltip(props: { reason: string; trigger: ReactElement }) {
return (
@@ -329,13 +346,7 @@ function RightPanelEmptyState(props: {
if (!action) return;
if (document.querySelector(LAUNCHER_SHORTCUT_BLOCKING_LAYERS)) return;
const target = event.target;
- if (target instanceof HTMLElement) {
- if (target.closest("input, textarea, select")) return;
- // An empty contenteditable (the chat composer at rest) does not
- // count as typing; letters only become text once a draft exists.
- const editable = target.isContentEditable ? target : target.closest("[contenteditable]");
- if (editable && (editable.textContent ?? "").trim().length > 0) return;
- }
+ if (target instanceof Element && surfaceShortcutTargetsTypingContext(target)) return;
event.preventDefault();
event.stopPropagation();
action.onClick();
@@ -812,29 +823,24 @@ export function RightPanelTabs(props: RightPanelTabsProps) {
: "text-muted-foreground hover:bg-accent/60 hover:text-foreground",
)}
>
-
+ ) : null}
+
{audio === "none" || !audioRuntimeTabId ? null : (
{
});
});
+describe("animatePinnedLayoutChanges", () => {
+ const baseArgs: Parameters[0] = {
+ active: null,
+ containerId: "pinned-threads",
+ isDragging: false,
+ isSorting: false,
+ id: "thread-a",
+ index: 1,
+ items: ["thread-b", "thread-a"],
+ newIndex: 0,
+ previousItems: ["thread-a", "thread-b"],
+ previousContainerId: "pinned-threads",
+ transition: { duration: 200, easing: "ease" },
+ wasDragging: true,
+ };
+
+ it("does not replay layout movement after the pointer is released", () => {
+ expect(defaultAnimateLayoutChanges(baseArgs)).toBe(true);
+ expect(animatePinnedLayoutChanges(baseArgs)).toBe(false);
+ });
+
+ it("keeps layout movement while the user is sorting", () => {
+ expect(animatePinnedLayoutChanges({ ...baseArgs, isSorting: true })).toBe(true);
+ });
+});
+
describe("shouldNavigateAfterProjectRemoval", () => {
const projectThreads = [{ environmentId: "environment-local", id: "thread-1" }];
diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.ts
index 3f995876468b..fa53339d46f2 100644
--- a/apps/web/src/components/Sidebar.logic.ts
+++ b/apps/web/src/components/Sidebar.logic.ts
@@ -1,4 +1,5 @@
import * as React from "react";
+import { defaultAnimateLayoutChanges, type AnimateLayoutChanges } from "@dnd-kit/sortable";
import {
effectiveSettled,
type ChangeRequestStateLike,
@@ -57,7 +58,7 @@ export function resolveSidebarProjectBadgeColorIndex(
}
export const THREAD_SELECTION_SAFE_SELECTOR = "[data-thread-item], [data-thread-selection-safe]";
-export const THREAD_JUMP_HINT_SHOW_DELAY_MS = 100;
+export const THREAD_JUMP_HINT_SHOW_DELAY_MS = 200;
// Visible sidebar rows are prewarmed into the thread-detail cache so opening a
// nearby thread usually reuses an already-hot subscription. Each prewarmed
// thread holds a live, fully hydrated detail subscription (all messages and
@@ -89,6 +90,12 @@ export type SidebarThreadWorktreeSection =
threads: SidebarThreadSummary[];
};
+// The list already reaches its destination through sortable transforms while
+// the pointer is down. dnd-kit's default also animates the committed DOM order
+// after release, replaying the same movement across every affected row.
+export const animatePinnedLayoutChanges: AnimateLayoutChanges = (args) =>
+ args.isSorting ? defaultAnimateLayoutChanges(args) : false;
+
type SidebarProject = {
id: string;
title: string;
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx
index eb9188fa92e2..ec5e862a4db9 100644
--- a/apps/web/src/components/Sidebar.tsx
+++ b/apps/web/src/components/Sidebar.tsx
@@ -95,11 +95,13 @@ import {
threadTraversalDirectionFromCommand,
} from "../keybindings";
import { useShortcutModifierState } from "../shortcutModifierState";
+import { useTerminalFocus } from "../hooks/useTerminalFocus";
import { isTerminalFocused } from "../lib/terminalFocus";
import { isModelPickerOpen } from "../modelPickerVisibility";
import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
import { isMacPlatform } from "~/lib/utils";
import { useOpenPrLink } from "../lib/openPullRequestLink";
+import { releaseComposerDraftUploads } from "../lib/composerDraftUploads";
import { readLocalApi } from "../localApi";
import { getProjectOrderKey, selectProjectGroupingSettings } from "../logicalProject";
import {
@@ -138,14 +140,12 @@ import {
requestIdentityClaimGate,
} from "./identity/IdentityClaimGate";
import {
- claimPersonIdForEnvironment,
DEFAULT_OWNERSHIP_RELATION,
isOwnershipRelation,
- threadMatchesMine,
- type OwnershipRelation,
} from "@t3tools/client-runtime/state/identity";
import { identityClaimPersonIdByEnvironmentAtom } from "../state/identity";
import {
+ animatePinnedLayoutChanges,
SETTLED_TAIL_INITIAL_COUNT,
SETTLED_TAIL_PAGE_COUNT,
buildBulkTitleRegenerationContextMenuItem,
@@ -166,6 +166,7 @@ import {
sortPinnedThreadsForSidebar,
sortSettledThreadsForSidebar,
sortThreadsForSidebar,
+ useThreadJumpHintVisibility,
} from "./Sidebar.logic";
import { resolveLocalCheckoutBranchMismatch } from "./BranchToolbar.logic";
import {
@@ -180,6 +181,7 @@ import {
threadChangeRequestSnapshotsAtom,
type ThreadChangeRequestSnapshot,
type TerminalStatusIndicator,
+ useLinkedThreadPullRequest,
} from "./ThreadStatusIndicators";
import {
resolveSnoozePresets,
@@ -194,11 +196,10 @@ import { getTriggerDisplayModelLabel } from "./chat/providerIconUtils";
import { resolveDriverUsage, usageDotFillClass, usageDotRingColor } from "../aiUsageState";
import { useAiUsageSnapshot } from "../hooks/useAiUsageSnapshot";
import {
- deriveProviderInstanceEntries,
+ deriveProviderEntriesByEnvironment,
shouldShowInstanceBadge,
type ProviderInstanceEntry,
} from "../providerInstances";
-import { primaryServerProvidersAtom } from "../state/server";
import { useThreadRunningTerminalIds } from "../state/terminalSessions";
import { stackedThreadToast, toastManager } from "./ui/toast";
import { Button } from "./ui/button";
@@ -322,6 +323,8 @@ function WorkingDuration(props: { startedAt: string | null }) {
);
}
+const EMPTY_PROVIDER_ENTRIES: ReadonlyMap = new Map();
+
function terminalProcessLabel(count: number): string {
return `${count} terminal ${count === 1 ? "process" : "processes"} running`;
}
@@ -537,6 +540,7 @@ function SortablePinnedThreadRow(props: {
}) {
const { listeners, setNodeRef, transform, transition, isDragging } = useSortable({
id: props.id,
+ animateLayoutChanges: animatePinnedLayoutChanges,
});
return props.children({ listeners, setNodeRef, transform, transition, isDragging });
}
@@ -739,6 +743,7 @@ const SidebarDraftBlock = memo(function SidebarDraftBlock(props: {
// The /draft/$draftId route redirects home on its own when the draft
// it renders disappears, so discarding the open draft needs no
// special-casing here.
+ releaseComposerDraftUploads(draftId);
clearDraftThread(draftId);
},
[clearDraftThread],
@@ -786,13 +791,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
autoSettleOnMerge: boolean;
// Same contract for thread.snooze/unsnooze.
snoozeSupported: boolean;
- // Renders the pin glyph. Pinned cards keep the full settle/snooze quick
- // actions: settling clears the pin server-side, and snoozing hides the
- // card until wake with the pin intact underneath. The glyph is also the
- // in-row pin state cue (the pinned block has no header), so it always
- // shows while pinned; it only becomes a clickable unpin quick-action once
- // the pinning capability is confirmed, and stays a passive marker while
- // the descriptor is not loaded. Pinning itself lives in the context menu.
+ // Pinned threads show the same pin marker in active, settled, and snoozed
+ // rows. The marker can unpin the thread when the server supports pinning.
pinningSupported: boolean;
isPinned: boolean;
// Present only on pinned cards whose server supports reordering: dnd-kit
@@ -890,6 +890,10 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
// timestamp counts as never-visited — corrupt local data must not eat
// the wake signal.
const gitCwd = thread.worktreePath ?? props.projectCwd;
+ const linkedPullRequestStatus = useLinkedThreadPullRequest(
+ thread.environmentId,
+ thread.linkedPullRequest,
+ );
const gitStatus = useEnvironmentQuery(
(thread.branch != null || thread.worktreePath !== null) && gitCwd !== null
? vcsEnvironment.listStatus({
@@ -904,6 +908,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
gitStatus: gitStatus.data,
snapshot: changeRequestSnapshot,
retainTerminalOnBranchMismatch,
+ linkedPullRequest: thread.linkedPullRequest,
+ linkedPullRequestStatus,
});
// A woken thread reappears at its original position (the sort is
@@ -1000,6 +1006,8 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
gitStatus: gitStatus.data,
snapshot: changeRequestSnapshot,
retainTerminalOnBranchMismatch,
+ linkedPullRequest: thread.linkedPullRequest,
+ linkedPullRequestStatus,
});
const prStatus = prStatusIndicator(pr, prProvider);
const settledPrHoverClass = pr ? settledPrHoverColorClass(pr.state) : undefined;
@@ -1009,15 +1017,19 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
gitStatus: gitStatus.data,
snapshot: changeRequestSnapshot,
retainTerminalOnBranchMismatch,
+ linkedPullRequest: thread.linkedPullRequest,
+ linkedPullRequestStatus,
});
if (nextSnapshot === undefined) return;
onChangeRequestSnapshot(threadKey, nextSnapshot);
}, [
changeRequestSnapshot,
gitStatus.data,
+ linkedPullRequestStatus,
onChangeRequestSnapshot,
retainTerminalOnBranchMismatch,
thread.branch,
+ thread.linkedPullRequest,
threadKey,
]);
@@ -1312,6 +1324,31 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: {
+
+ Unpin thread
+
+ ) : (
+
+ Un-settle thread
+
) : (
)}
- {props.isPinned ? (
- props.pinningSupported ? (
-
- Unpin thread
-
- ) : (
-
-
- scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
- )
- .filter((threadKey) => reorderablePinnedKeys.has(threadKey))}
- strategy={verticalListSortingStrategy}
- >
- {orderedPinnedThreads.map((thread) => {
- const threadKey = scopedThreadKey(
- scopeThreadRef(thread.environmentId, thread.id),
- );
- if (!reorderablePinnedKeys.has(threadKey)) {
- return renderThreadRow(thread, "pinned");
- }
- return (
-
- {(bag) => renderThreadRow(thread, "pinned", bag)}
-
- );
- })}
-
- ,
+ pinnedThreads.length > 0 ? (
+
+
+
+ scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
+ )
+ .filter((threadKey) => reorderablePinnedKeys.has(threadKey))}
+ strategy={verticalListSortingStrategy}
+ >
+
+ {orderedPinnedThreads.map((thread) => {
+ const threadKey = scopedThreadKey(
+ scopeThreadRef(thread.environmentId, thread.id),
+ );
+ if (!reorderablePinnedKeys.has(threadKey)) {
+ return renderThreadRow(thread, "pinned");
+ }
+ return (
+
+ {(bag) => renderThreadRow(thread, "pinned", bag)}
+
+ );
+ })}
+
+
+
+
+ ) : null,
];
if (pinnedThreads.length > 0) {
items.push(
@@ -4355,7 +4405,7 @@ export default function Sidebar() {
,
+ title: "Resume with less context",
+ description: "250k tokens from an older session",
+ actions: (
+
+ ),
+ dismissLabel: "Keep full history",
+ onDismiss: () => {},
+ },
+ ]}
+ />,
+ );
+
+ expect(markup).toContain('role="alert"');
+ expect(markup).toContain("chat-composer-drawer-attached");
+ expect(markup).toContain('disabled=""');
+ expect(markup).toContain('aria-label="Keep full history"');
+ });
});
diff --git a/apps/web/src/components/chat/ComposerCommandMenu.test.tsx b/apps/web/src/components/chat/ComposerCommandMenu.test.tsx
index d16be51cc392..cf0a1747dd4c 100644
--- a/apps/web/src/components/chat/ComposerCommandMenu.test.tsx
+++ b/apps/web/src/components/chat/ComposerCommandMenu.test.tsx
@@ -51,10 +51,12 @@ describe("ComposerCommandMenu", () => {
expect(markup).not.toContain(" {
+ it("renders the skill source icon inside its badge", () => {
const markup = renderToStaticMarkup(
{
);
expect(markup).toContain("Browser");
- expect(markup).toContain('App skill');
+ expect(markup).toContain('data-slot="badge"');
+ expect(markup).toContain(">App Skill");
+ expect(markup).toContain("Open and control the in-app browser");
+ expect(markup).toContain("max-w-[48ch]");
+ expect(markup).toContain("text-secondary-label text-xs");
+ expect(markup).toContain("ms-auto");
+ expect(markup).toContain("text-current");
+ expect(markup.indexOf("Open and control the in-app browser")).toBeLessThan(
+ markup.indexOf(">App Skill"),
+ );
expect(markup).toContain(" {
+ const markup = renderToStaticMarkup(
+ {}}
+ onSelect={() => {}}
+ />,
+ );
+
+ expect(markup).toContain('/skill:Ask Matt');
+ expect(markup).toContain('data-slot="badge"');
+ expect(markup).toContain("lucide-folder");
+ expect(markup).toContain(">Repo");
+ expect(markup).toContain("Find the right skill or workflow");
+ expect(markup).not.toContain("font-medium text-secondary-label");
});
});
diff --git a/apps/web/src/components/chat/ComposerCommandMenu.tsx b/apps/web/src/components/chat/ComposerCommandMenu.tsx
index 239f2fe02f63..72267fcc9948 100644
--- a/apps/web/src/components/chat/ComposerCommandMenu.tsx
+++ b/apps/web/src/components/chat/ComposerCommandMenu.tsx
@@ -1,4 +1,5 @@
import {
+ formatProviderSkillDisplayName,
resolveProviderSkillSourceKind,
type ProviderSkillSourceKind,
} from "@t3tools/client-runtime/providerSkills";
@@ -10,7 +11,6 @@ import {
} from "@t3tools/contracts";
import {
BlocksIcon,
- FolderGit2Icon,
FolderIcon,
PackageIcon,
SettingsIcon,
@@ -21,6 +21,7 @@ import { memo, useLayoutEffect, useRef } from "react";
import { type ComposerSlashCommand, type ComposerTriggerKind } from "../../composer-logic";
import { cn } from "~/lib/utils";
+import { Badge } from "../ui/badge";
import { Command, CommandGroup, CommandItem, CommandList } from "../ui/command";
import { PierreEntryIcon } from "./PierreEntryIcon";
@@ -99,6 +100,7 @@ export const ComposerCommandMenu = memo(function ComposerCommandMenu(props: {
void;
@@ -137,6 +140,8 @@ const ComposerCommandMenuItem = memo(function ComposerCommandMenuItem(props: {
}) {
const skillSourceKind =
props.item.type === "skill" ? resolveProviderSkillSourceKind(props.item.skill) : null;
+ const isSlashSkill =
+ props.triggerKind === "slash-command" && props.item.type === "skill" ? props.item.skill : null;
return (
= {
app: BlocksIcon,
- repo: FolderGit2Icon,
+ repo: FolderIcon,
project: FolderIcon,
personal: UserRoundIcon,
system: SettingsIcon,
@@ -190,15 +208,16 @@ const SKILL_SOURCE_LABEL_BY_KIND: Record = {
project: "Project",
personal: "Personal",
system: "System",
- other: "Other",
+ other: "Provider",
};
-function SkillSourceIcon(props: { kind: ProviderSkillSourceKind }) {
+function SkillSourceBadge(props: { kind: ProviderSkillSourceKind; showSkillSuffix: boolean }) {
const Icon = SKILL_SOURCE_ICON_BY_KIND[props.kind];
return (
- <>
-
- {SKILL_SOURCE_LABEL_BY_KIND[props.kind]} skill
-
+
+
+ {SKILL_SOURCE_LABEL_BY_KIND[props.kind]}
+ {props.showSkillSuffix ? " Skill" : null}
+
);
}
diff --git a/apps/web/src/components/chat/ComposerControl.tsx b/apps/web/src/components/chat/ComposerControl.tsx
index a7ba40581457..c0f15a581dad 100644
--- a/apps/web/src/components/chat/ComposerControl.tsx
+++ b/apps/web/src/components/chat/ComposerControl.tsx
@@ -6,7 +6,7 @@ import { Button } from "../ui/button";
import { SelectTrigger } from "../ui/select";
const composerControlClassName =
- "h-7 min-h-7 gap-1.5 px-2.5 text-secondary-label transition-none hover:text-foreground [&_svg[data-composer-control-icon]]:mx-0 [&_svg[data-composer-control-chevron]]:-mx-0.5";
+ "h-7 min-h-7 gap-1.5 rounded-[var(--control-radius)] px-2.5 text-secondary-label transition-none hover:text-foreground [&_svg[data-composer-control-icon]]:mx-0 [&_svg[data-composer-control-chevron]]:-mx-0.5";
export function ComposerControl({
className,
diff --git a/apps/web/src/components/chat/ComposerPendingApprovalActions.test.tsx b/apps/web/src/components/chat/ComposerPendingApprovalActions.test.tsx
index 74e25b9c8e15..16141270f6f4 100644
--- a/apps/web/src/components/chat/ComposerPendingApprovalActions.test.tsx
+++ b/apps/web/src/components/chat/ComposerPendingApprovalActions.test.tsx
@@ -21,4 +21,38 @@ describe("ComposerPendingApprovalActions", () => {
expect(markup).toContain("sm:text-[11px]");
expect(markup).not.toContain("sm:h-6");
});
+
+ it("shows only the approval choices advertised by an MCP server", () => {
+ const markup = renderToStaticMarkup(
+ undefined}
+ />,
+ );
+
+ expect(markup).toContain("Always allow Safari");
+ expect(markup).toContain(">Approve<");
+ expect(markup).not.toContain("Always allow this session");
+ });
+
+ it("limits provider-supplied approval labels so narrow rows can wrap", () => {
+ const label = "Allow ".repeat(40).trim();
+ const markup = renderToStaticMarkup(
+ undefined}
+ />,
+ );
+
+ expect(markup).toContain('class="max-w-40 truncate"');
+ expect(markup).toContain(label);
+ });
});
diff --git a/apps/web/src/components/chat/ComposerPendingApprovalActions.tsx b/apps/web/src/components/chat/ComposerPendingApprovalActions.tsx
index ef2bc59dd361..7482f665bd11 100644
--- a/apps/web/src/components/chat/ComposerPendingApprovalActions.tsx
+++ b/apps/web/src/components/chat/ComposerPendingApprovalActions.tsx
@@ -1,10 +1,15 @@
-import { type ApprovalRequestId, type ProviderApprovalDecision } from "@t3tools/contracts";
+import {
+ type ApprovalRequestId,
+ type ProviderApprovalDecision,
+ type ProviderApprovalOption,
+} from "@t3tools/contracts";
import { memo } from "react";
import { Button } from "../ui/button";
interface ComposerPendingApprovalActionsProps {
requestId: ApprovalRequestId;
isResponding: boolean;
+ options?: ReadonlyArray | undefined;
onRespondToApproval: (
requestId: ApprovalRequestId,
decision: ProviderApprovalDecision,
@@ -12,50 +17,39 @@ interface ComposerPendingApprovalActionsProps {
}
const APPROVAL_ACTION_CLASS_NAME = "font-normal";
+const DEFAULT_APPROVAL_OPTIONS = [
+ { decision: "cancel", label: "Cancel" },
+ { decision: "decline", label: "Decline" },
+ { decision: "acceptForSession", label: "Always allow this session" },
+ { decision: "accept", label: "Approve" },
+] satisfies ReadonlyArray;
export const ComposerPendingApprovalActions = memo(function ComposerPendingApprovalActions({
requestId,
isResponding,
+ options = DEFAULT_APPROVAL_OPTIONS,
onRespondToApproval,
}: ComposerPendingApprovalActionsProps) {
return (
<>
-
-
-
-
+ {options.map((option) => (
+
+ ))}
);
});
diff --git a/apps/web/src/components/chat/ComposerPendingApprovalPanel.test.tsx b/apps/web/src/components/chat/ComposerPendingApprovalPanel.test.tsx
index 5e82298d50f0..a7ef6bc7d5cb 100644
--- a/apps/web/src/components/chat/ComposerPendingApprovalPanel.test.tsx
+++ b/apps/web/src/components/chat/ComposerPendingApprovalPanel.test.tsx
@@ -50,4 +50,46 @@ describe("ComposerPendingApprovalPanel", () => {
expect(markup).toContain("File read approval");
});
+
+ it("shows the app name and message for an MCP access request", () => {
+ const markup = renderToStaticMarkup(
+ {
expect(markup).toContain('aria-label="Remove preview annotation"');
expect(markup).toContain('data-slot="button"');
});
+
+ it("shows a retry action for a failed screenshot upload", () => {
+ const image = {
+ type: "image" as const,
+ id: annotation.id,
+ name: "annotation.png",
+ mimeType: "image/png",
+ sizeBytes: 3,
+ previewUrl: "blob:annotation",
+ file: new File([new Uint8Array([1, 2, 3])], "annotation.png", { type: "image/png" }),
+ };
+ const markup = renderToStaticMarkup(
+ ;
onRemove: (annotationId: string) => void;
onExpandImage: (imageId: string) => void;
+ uploadsByImageId?: Readonly>;
+ onRetryUpload?: (image: ComposerImageAttachment) => void;
className?: string;
}
@@ -38,6 +44,8 @@ export function ComposerPreviewAnnotationCards({
images,
onRemove,
onExpandImage,
+ uploadsByImageId,
+ onRetryUpload,
className,
}: ComposerPreviewAnnotationCardsProps) {
if (annotations.length === 0) return null;
@@ -47,6 +55,7 @@ export function ComposerPreviewAnnotationCards({
{annotations.map((annotation) => {
const image = imagesById.get(annotation.id);
+ const upload = image ? uploadsByImageId?.[image.id] : undefined;
const elementLabels = annotation.elements.flatMap((target) => {
const context = normalizeElementContextSelection(target.element);
return context ? [{ id: target.id, label: formatElementContextLabel(context) }] : [];
@@ -132,6 +141,28 @@ export function ComposerPreviewAnnotationCards({
label="style change"
/>
) : null}
+ {upload?.status === "uploading" ? (
+
+ {formatAttachmentUploadProgress(upload.progress)}
+
+ ) : null}
+ {upload?.status === "failed" && image && onRetryUpload ? (
+
+ onRetryUpload(image)}
+ />
+ }
+ >
+
+ {upload.reason}
+
+ ) : null}
diff --git a/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx b/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx
index e24142afeffb..9cddef80f6c1 100644
--- a/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx
+++ b/apps/web/src/components/chat/ComposerPrimaryActions.test.tsx
@@ -114,7 +114,7 @@ function renderRunningActions(showSendWhileRunning: boolean, hasSendableContent:
);
}
-function renderSendButton() {
+function renderSendButton(sendDisabledReason: string | null = null) {
return renderToStaticMarkup(
createElement(ComposerPrimaryActions, {
compact: true,
@@ -123,7 +123,7 @@ function renderSendButton() {
showPlanFollowUpPrompt: false,
promptHasText: true,
isSendBusy: false,
- sendDisabledReason: null,
+ sendDisabledReason,
isConnecting: false,
isEnvironmentUnavailable: false,
isPreparingWorktree: false,
@@ -231,6 +231,13 @@ describe("formatPendingPrimaryActionLabel", () => {
});
describe("ComposerPrimaryActions", () => {
+ it("disables and labels the send button while feedback is uploading", () => {
+ const markup = renderSendButton("Sending feedback");
+
+ expect(markup).toContain("disabled");
+ expect(markup).toContain('aria-label="Sending feedback"');
+ });
+
it("offers Stop generation while a running turn is waiting for user input", () => {
expect(renderPendingActions(true)).toContain('aria-label="Stop generation"');
});
diff --git a/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts b/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts
index 012d9130ac62..032076c0b74b 100644
--- a/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts
+++ b/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts
@@ -1,10 +1,83 @@
-import { ProviderInstanceId } from "@t3tools/contracts";
+import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
+import { deriveProviderInstanceEntries } from "../../providerInstances";
import {
formatContextWindowCompactionMessage,
+ hasAvailableClaudeCompactionProvider,
+ hasDismissedResumeCompaction,
resolveContextWindowModelDisplayName,
+ shouldOfferResumeCompaction,
} from "./ContextWindowMeter.logic";
+function claudeProvider(input: {
+ instanceId: string;
+ continuationGroupKey: string;
+ enabled?: boolean;
+}): ServerProvider {
+ return {
+ instanceId: ProviderInstanceId.make(input.instanceId),
+ driver: ProviderDriverKind.make("claudeAgent"),
+ continuation: { groupKey: input.continuationGroupKey },
+ enabled: input.enabled ?? true,
+ installed: true,
+ version: null,
+ status: "ready",
+ auth: { status: "authenticated" },
+ checkedAt: "2026-08-24T12:00:00.000Z",
+ models: [],
+ slashCommands: [],
+ skills: [],
+ };
+}
+
+describe("hasAvailableClaudeCompactionProvider", () => {
+ const originalInstanceId = ProviderInstanceId.make("claude_original");
+
+ it("rejects a fallback in a different locked continuation group", () => {
+ const providers = deriveProviderInstanceEntries([
+ claudeProvider({
+ instanceId: originalInstanceId,
+ continuationGroupKey: "claude:home:/original",
+ enabled: false,
+ }),
+ claudeProvider({
+ instanceId: "claude_other",
+ continuationGroupKey: "claude:home:/other",
+ }),
+ ]);
+
+ expect(
+ hasAvailableClaudeCompactionProvider({
+ providers,
+ instanceId: originalInstanceId,
+ lockedInstanceId: originalInstanceId,
+ }),
+ ).toBe(false);
+ });
+
+ it("accepts an enabled fallback in the locked continuation group", () => {
+ const providers = deriveProviderInstanceEntries([
+ claudeProvider({
+ instanceId: originalInstanceId,
+ continuationGroupKey: "claude:home:/original",
+ enabled: false,
+ }),
+ claudeProvider({
+ instanceId: "claude_fallback",
+ continuationGroupKey: "claude:home:/original",
+ }),
+ ]);
+
+ expect(
+ hasAvailableClaudeCompactionProvider({
+ providers,
+ instanceId: originalInstanceId,
+ lockedInstanceId: originalInstanceId,
+ }),
+ ).toBe(true);
+ });
+});
+
describe("resolveContextWindowModelDisplayName", () => {
it("uses the selected model from the exact provider instance", () => {
const primaryInstanceId = ProviderInstanceId.make("codex");
@@ -55,4 +128,109 @@ describe("formatContextWindowCompactionMessage", () => {
"Context compacts automatically when needed.",
);
});
+
+ it("shows the configured auto-compaction threshold", () => {
+ expect(formatContextWindowCompactionMessage("Claude Sonnet 5", 300_000)).toBe(
+ "Compacts automatically at 300,000 tokens.",
+ );
+ });
+});
+
+describe("shouldOfferResumeCompaction", () => {
+ const now = "2026-08-24T12:00:00.000Z";
+
+ it("matches Claude's old-session age and context thresholds", () => {
+ expect(
+ shouldOfferResumeCompaction({
+ provider: "claudeAgent",
+ usedTokens: 100_000,
+ updatedAt: "2026-08-24T10:50:00.000Z",
+ now,
+ }),
+ ).toBe(true);
+ });
+
+ it("does not prompt for recent or smaller sessions", () => {
+ expect(
+ shouldOfferResumeCompaction({
+ provider: "claudeAgent",
+ usedTokens: 99_999,
+ updatedAt: "2026-08-24T10:00:00.000Z",
+ now,
+ }),
+ ).toBe(false);
+ expect(
+ shouldOfferResumeCompaction({
+ provider: "claudeAgent",
+ usedTokens: 200_000,
+ updatedAt: "2026-08-24T10:51:00.000Z",
+ now,
+ }),
+ ).toBe(false);
+ });
+
+ it("does not show Claude's resume prompt for another provider", () => {
+ expect(
+ shouldOfferResumeCompaction({
+ provider: "codex",
+ usedTokens: 300_000,
+ updatedAt: "2026-08-24T09:00:00.000Z",
+ now,
+ }),
+ ).toBe(false);
+ });
+});
+
+describe("hasDismissedResumeCompaction", () => {
+ it("recognizes the native resume dialog's permanent dismissal", () => {
+ expect(
+ hasDismissedResumeCompaction([
+ {
+ kind: "user-input.resolved",
+ payload: {
+ answers: {
+ "This session is 2h 0m old and uses 250,000 tokens. Compact it before continuing?":
+ "Don't ask again",
+ },
+ },
+ },
+ ]),
+ ).toBe(true);
+ });
+
+ it("ignores the same answer on an unrelated question", () => {
+ expect(
+ hasDismissedResumeCompaction([
+ {
+ kind: "user-input.resolved",
+ payload: { answers: { "Show this setup reminder?": "Don't ask again" } },
+ },
+ ]),
+ ).toBe(false);
+ });
+
+ it("ignores unrelated questions that end with Claude's compaction prompt", () => {
+ expect(
+ hasDismissedResumeCompaction([
+ {
+ kind: "user-input.resolved",
+ payload: {
+ answers: {
+ "The build cache is large. Compact it before continuing?": "Don't ask again",
+ },
+ },
+ },
+ ]),
+ ).toBe(false);
+ });
+
+ it("ignores pending questions and malformed resolved payloads", () => {
+ expect(
+ hasDismissedResumeCompaction([
+ { kind: "user-input.requested", payload: { answers: { question: "Don't ask again" } } },
+ { kind: "user-input.resolved", payload: null },
+ { kind: "user-input.resolved", payload: { answers: ["Don't ask again"] } },
+ ]),
+ ).toBe(false);
+ });
});
diff --git a/apps/web/src/components/chat/ContextWindowMeter.logic.ts b/apps/web/src/components/chat/ContextWindowMeter.logic.ts
index c87170ffe610..8e46c16e9a09 100644
--- a/apps/web/src/components/chat/ContextWindowMeter.logic.ts
+++ b/apps/web/src/components/chat/ContextWindowMeter.logic.ts
@@ -1,6 +1,81 @@
import type { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";
+import {
+ CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,
+ isClaudeResumeCompactionQuestion,
+} from "@t3tools/shared/claudeCompaction";
+import {
+ resolveSelectableProviderInstanceEntry,
+ type ProviderInstanceEntry,
+} from "../../providerInstances";
import { getTriggerDisplayModelName, type ModelEsque } from "./providerIconUtils";
+export const CLAUDE_RESUME_COMPACTION_MINUTES = 70;
+export const CLAUDE_RESUME_COMPACTION_TOKENS = 100_000;
+
+export function hasAvailableClaudeCompactionProvider(input: {
+ readonly providers: ReadonlyArray;
+ readonly instanceId: ProviderInstanceId | null;
+ readonly lockedInstanceId: ProviderInstanceId | null;
+}): boolean {
+ const claudeProviders = input.providers.filter(
+ (provider) => provider.driverKind === "claudeAgent",
+ );
+ const lockedContinuationGroupKey = input.lockedInstanceId
+ ? claudeProviders.find((provider) => provider.instanceId === input.lockedInstanceId)
+ ?.continuationGroupKey
+ : undefined;
+ const compatibleProviders = lockedContinuationGroupKey
+ ? claudeProviders.filter(
+ (provider) => provider.continuationGroupKey === lockedContinuationGroupKey,
+ )
+ : claudeProviders;
+
+ return (
+ resolveSelectableProviderInstanceEntry(compatibleProviders, input.instanceId ?? undefined) !==
+ undefined
+ );
+}
+
+export function hasDismissedResumeCompaction(
+ activities: ReadonlyArray<{ readonly kind: string; readonly payload: unknown }>,
+): boolean {
+ return activities.some((activity) => {
+ if (activity.kind !== "user-input.resolved") return false;
+ const payload = activity.payload;
+ if (!payload || typeof payload !== "object") return false;
+ const answers = (payload as { readonly answers?: unknown }).answers;
+ if (!answers || typeof answers !== "object" || Array.isArray(answers)) return false;
+
+ return Object.entries(answers).some(
+ ([question, answer]) =>
+ isClaudeResumeCompactionQuestion(question) &&
+ answer === CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,
+ );
+ });
+}
+
+export function shouldOfferResumeCompaction(input: {
+ readonly provider: string | null | undefined;
+ readonly usedTokens: number | null | undefined;
+ readonly updatedAt: string | null | undefined;
+ readonly now: string;
+}): boolean {
+ if (
+ input.provider !== "claudeAgent" ||
+ (input.usedTokens ?? 0) < CLAUDE_RESUME_COMPACTION_TOKENS
+ ) {
+ return false;
+ }
+
+ const updatedAt = Date.parse(input.updatedAt ?? "");
+ const now = Date.parse(input.now);
+ return (
+ Number.isFinite(updatedAt) &&
+ Number.isFinite(now) &&
+ now - updatedAt >= CLAUDE_RESUME_COMPACTION_MINUTES * 60_000
+ );
+}
+
export function resolveContextWindowModelDisplayName(
selection: ModelSelection | null | undefined,
modelOptionsByInstance: ReadonlyMap>,
@@ -18,7 +93,11 @@ export function resolveContextWindowModelDisplayName(
export function formatContextWindowCompactionMessage(
modelDisplayName: string | null | undefined,
+ autoCompactThreshold?: number | null,
): string {
+ if (typeof autoCompactThreshold === "number" && autoCompactThreshold > 0) {
+ return `Compacts automatically at ${autoCompactThreshold.toLocaleString("en-US")} tokens.`;
+ }
return modelDisplayName
? `Context for ${modelDisplayName} compacts automatically when needed.`
: "Context compacts automatically when needed.";
diff --git a/apps/web/src/components/chat/ContextWindowMeter.test.tsx b/apps/web/src/components/chat/ContextWindowMeter.test.tsx
new file mode 100644
index 000000000000..90617ca63af1
--- /dev/null
+++ b/apps/web/src/components/chat/ContextWindowMeter.test.tsx
@@ -0,0 +1,62 @@
+import { EventId, TurnId } from "@t3tools/contracts";
+import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vite-plus/test";
+
+import { deriveLatestContextWindowSnapshot } from "~/lib/contextWindow";
+import { ContextWindowMeter } from "./ContextWindowMeter";
+
+vi.mock("../ui/popover", () => ({
+ Popover: ({ children }: { children: ReactNode }) => children,
+ PopoverPopup: ({ children }: { children: ReactNode }) => children,
+ PopoverTrigger: ({ closeDelay, render }: { closeDelay: number; render: ReactNode }) => (
+ {render}
+ ),
+}));
+
+const usage = deriveLatestContextWindowSnapshot([
+ {
+ id: EventId.make("activity-1"),
+ tone: "info",
+ kind: "context-window.updated",
+ summary: "Context updated",
+ payload: { usedTokens: 100_000, maxTokens: 1_000_000 },
+ turnId: TurnId.make("turn-1"),
+ createdAt: "2026-08-24T12:00:00.000Z",
+ },
+]);
+
+if (!usage) {
+ throw new Error("The context window test fixture did not produce a snapshot.");
+}
+
+describe("ContextWindowMeter", () => {
+ it("keeps the hover popover open while the pointer moves to the compact button", () => {
+ const markup = renderToStaticMarkup( {}} />);
+
+ expect(markup).toContain('data-close-delay="150"');
+ expect(markup).toContain("Compact context");
+ });
+
+ it("closes an informational hover popover without delay", () => {
+ const markup = renderToStaticMarkup( {}}
+ compactDisabled
+ compactDisabledReason="Send or clear your draft before compacting"
+ />,
+ );
+
+ expect(markup).toContain('disabled=""');
+ expect(markup).toContain(">Send or clear your draft before compacting<");
+ expect(markup).not.toContain('aria-label="Send or clear your draft before compacting"');
+ });
+});
diff --git a/apps/web/src/components/chat/ContextWindowMeter.tsx b/apps/web/src/components/chat/ContextWindowMeter.tsx
index 6943684b1f58..93809c4f686c 100644
--- a/apps/web/src/components/chat/ContextWindowMeter.tsx
+++ b/apps/web/src/components/chat/ContextWindowMeter.tsx
@@ -2,6 +2,7 @@ import { Button } from "../ui/button";
import { type ContextWindowSnapshot, formatContextWindowTokens } from "~/lib/contextWindow";
import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
import { formatContextWindowCompactionMessage } from "./ContextWindowMeter.logic";
+import { Minimize2Icon } from "lucide-react";
function formatPercentage(value: number | null): string | null {
if (value === null || !Number.isFinite(value)) {
@@ -16,8 +17,11 @@ function formatPercentage(value: number | null): string | null {
export function ContextWindowMeter(props: {
usage: ContextWindowSnapshot;
modelDisplayName?: string | null;
+ onCompact?: (() => void) | undefined;
+ compactDisabled?: boolean | undefined;
+ compactDisabledReason?: string | null | undefined;
}) {
- const { usage, modelDisplayName } = props;
+ const { usage, modelDisplayName, onCompact, compactDisabled, compactDisabledReason } = props;
const usedPercentage = formatPercentage(usage.usedPercentage);
const normalizedPercentage = Math.max(0, Math.min(100, usage.usedPercentage ?? 0));
const radius = 9.75;
@@ -35,7 +39,7 @@ export function ContextWindowMeter(props: {
- {formatContextWindowCompactionMessage(modelDisplayName)}
+ {formatContextWindowCompactionMessage(modelDisplayName, usage.autoCompactThreshold)}
) : null}
+ {onCompact ? (
+ <>
+
+ {compactDisabled && compactDisabledReason ? (
+
+ {compactDisabledReason}
+
+ ) : null}
+
+ ) : null}
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index 821d2dbd7ee1..1a6b2fdd64f0 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -460,7 +460,7 @@ describe("deriveMessagesTimelineRows", () => {
expect(assistantRow?.assistantTurnDiffSummary).toBe(assistantTurnDiffSummary);
});
- it("folds settled-turn commentary and work behind a Worked-for row", () => {
+ it("keeps the first and terminal assistant messages visible around settled work", () => {
const timelineEntries = [
{
id: "user-entry",
@@ -477,13 +477,13 @@ describe("deriveMessagesTimelineRows", () => {
},
},
{
- id: "assistant-thought-entry",
+ id: "assistant-first-entry",
kind: "message" as const,
createdAt: "2026-01-01T00:00:05Z",
message: {
- id: "assistant-thought" as never,
+ id: "assistant-first" as never,
role: "assistant" as const,
- text: "Looking around first.",
+ text: "Synthetic deployment checklist\n1. Confirm the deployment is ready.",
turnId: "turn-1" as never,
createdAt: "2026-01-01T00:00:05Z",
updatedAt: "2026-01-01T00:00:06Z",
@@ -545,6 +545,7 @@ describe("deriveMessagesTimelineRows", () => {
expect(foldRow?.label).toBe("Worked for 22s");
expect(collapsedRows.map((row) => row.id)).toEqual([
"user-entry",
+ "assistant-first-entry",
"turn-fold:turn-1",
"assistant-final-entry",
]);
@@ -560,8 +561,8 @@ describe("deriveMessagesTimelineRows", () => {
expect(expandedRows.map((row) => row.id)).toEqual([
"user-entry",
+ "assistant-first-entry",
"turn-fold:turn-1",
- "assistant-thought-entry",
"work-toggle:work-entry-1",
"assistant-final-entry",
]);
@@ -679,6 +680,67 @@ describe("deriveMessagesTimelineRows", () => {
expect(ids).not.toContain("work-1");
});
+ it("folds assistant messages between the first and terminal messages", () => {
+ const timelineEntries = [
+ {
+ id: "assistant-first-entry",
+ kind: "message" as const,
+ createdAt: "2026-01-01T00:00:01Z",
+ message: {
+ id: "assistant-first" as never,
+ role: "assistant" as const,
+ text: "The main result is ready.",
+ turnId: "turn-1" as never,
+ createdAt: "2026-01-01T00:00:01Z",
+ updatedAt: "2026-01-01T00:00:02Z",
+ streaming: false,
+ },
+ },
+ {
+ id: "assistant-middle-entry",
+ kind: "message" as const,
+ createdAt: "2026-01-01T00:00:03Z",
+ message: {
+ id: "assistant-middle" as never,
+ role: "assistant" as const,
+ text: "I am checking one more detail.",
+ turnId: "turn-1" as never,
+ createdAt: "2026-01-01T00:00:03Z",
+ updatedAt: "2026-01-01T00:00:04Z",
+ streaming: false,
+ },
+ },
+ {
+ id: "assistant-final-entry",
+ kind: "message" as const,
+ createdAt: "2026-01-01T00:00:05Z",
+ message: {
+ id: "assistant-final" as never,
+ role: "assistant" as const,
+ text: "Verification finished.",
+ turnId: "turn-1" as never,
+ createdAt: "2026-01-01T00:00:05Z",
+ updatedAt: "2026-01-01T00:00:06Z",
+ streaming: false,
+ },
+ },
+ ];
+
+ const rows = deriveMessagesTimelineRows({
+ timelineEntries,
+ isWorking: false,
+ activeTurnStartedAt: null,
+ turnDiffSummaryByAssistantMessageId: new Map(),
+ revertTurnCountByUserMessageId: new Map(),
+ });
+
+ expect(rows.map((row) => row.id)).toEqual([
+ "assistant-first-entry",
+ "turn-fold:turn-1",
+ "assistant-final-entry",
+ ]);
+ });
+
it("derives a sane duration for a steer-superseded turn with one instant commentary message", () => {
// A steer ends the previous turn early: its only message completes the
// instant it is created, and trailing work entries land after it. The
@@ -1799,6 +1861,88 @@ describe("deriveMessagesTimelineRows", () => {
clearSteerTimelineBoundaryStore();
});
+
+ it.each([
+ ["recovered", ["failed", "completed"], false],
+ ["ending in failure", ["completed", "failed"], true],
+ ["failed", ["failed", "failed"], true],
+ ] as const)("uses the final call for %s tool groups", (_, statuses, hasFailure) => {
+ const timelineEntries = statuses.map((status, index) => ({
+ id: `work-entry-${index}`,
+ kind: "work" as const,
+ createdAt: `2026-01-01T00:00:0${index}Z`,
+ entry: {
+ id: `work-${index}`,
+ createdAt: `2026-01-01T00:00:0${index}Z`,
+ label: "Ran command",
+ tone: "tool" as const,
+ itemType: "command_execution" as const,
+ toolLifecycleStatus: status,
+ },
+ }));
+
+ const rows = deriveMessagesTimelineRows({
+ timelineEntries,
+ isWorking: false,
+ activeTurnStartedAt: null,
+ turnDiffSummaryByAssistantMessageId: new Map(),
+ revertTurnCountByUserMessageId: new Map(),
+ });
+
+ expect(rows.find((row) => row.kind === "work-toggle")).toMatchObject({
+ hiddenCount: 2,
+ hasFailure,
+ });
+ });
+
+ it.each([
+ ["the later success is hidden", ["failed", "completed", "info"], false],
+ ["the later success is visible", ["failed", "info", "completed"], false],
+ ["an error-toned entry recovers", ["error", "info", "completed"], false],
+ ["the final failure is hidden", ["completed", "failed", "info"], true],
+ ["the final failure is visible", ["failed", "info", "failed"], true],
+ ["the only failure is visible", ["completed", "info", "failed"], false],
+ ] as const)(
+ "uses the final tool call for mixed work groups when %s",
+ (_, statuses, hasFailure) => {
+ const timelineEntries = statuses.map((status, index) => {
+ const id = `work-${index}`;
+ const createdAt = `2026-01-01T00:00:0${index}Z`;
+
+ return {
+ id: `work-entry-${index}`,
+ kind: "work" as const,
+ createdAt,
+ entry:
+ status === "info"
+ ? { id, createdAt, label: "Status updated", tone: "info" as const }
+ : status === "error"
+ ? { id, createdAt, label: "Command failed", tone: "error" as const }
+ : {
+ id,
+ createdAt,
+ label: "Ran command",
+ tone: "tool" as const,
+ toolLifecycleStatus: status,
+ },
+ };
+ });
+
+ const rows = deriveMessagesTimelineRows({
+ timelineEntries,
+ isWorking: false,
+ activeTurnStartedAt: null,
+ turnDiffSummaryByAssistantMessageId: new Map(),
+ revertTurnCountByUserMessageId: new Map(),
+ });
+
+ expect(rows.find((row) => row.kind === "work-toggle")).toMatchObject({
+ hiddenCount: 2,
+ summary: null,
+ hasFailure,
+ });
+ },
+ );
});
describe("computeStableMessagesTimelineRows", () => {
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 9a5721fb4d59..9375ebaa1344 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -552,9 +552,10 @@ function timelineEntryTurnId(entry: TimelineEntry): TurnId | null {
}
/**
- * Settled turns fold their commentary and tool activity behind a
- * "Worked for ..." row anchored at the turn's first foldable entry; the
- * terminal assistant message stays visible below the fold.
+ * Settled turns keep their first and terminal assistant messages visible.
+ * Everything between them folds behind a "Worked for ..." row anchored at
+ * the first hidden entry. Keeping both ends prevents a short follow-up from
+ * hiding a substantive opening response while still bounding noisy turns.
*/
function deriveTurnFolds(input: {
timelineEntries: ReadonlyArray;
@@ -673,9 +674,12 @@ function deriveTurnFolds(input: {
if (group.hasStreamingMessage) {
continue;
}
+ const firstAssistantEntry = group.entries.find(
+ (entry): entry is Extract => entry.kind === "message",
+ );
const hiddenEntryIds = new Set();
for (const entry of group.entries) {
- if (entry.id === group.terminalEntry?.id) {
+ if (entry.id === firstAssistantEntry?.id || entry.id === group.terminalEntry?.id) {
continue;
}
// Agent-spawn CTA rows never fold: workflows outlive their launching
@@ -696,8 +700,9 @@ function deriveTurnFolds(input: {
}
const firstEntry = group.entries[0];
+ const firstHiddenEntry = group.entries.find((entry) => hiddenEntryIds.has(entry.id));
const lastEntry = group.entries.at(-1);
- if (!firstEntry || !lastEntry) {
+ if (!firstEntry || !firstHiddenEntry || !lastEntry) {
continue;
}
@@ -726,10 +731,10 @@ function deriveTurnFolds(input: {
? `Worked for ${duration}`
: "Worked";
- foldsByAnchorEntryId.set(firstEntry.id, {
+ foldsByAnchorEntryId.set(firstHiddenEntry.id, {
turnId,
- anchorEntryId: firstEntry.id,
- createdAt: firstEntry.createdAt,
+ anchorEntryId: firstHiddenEntry.id,
+ createdAt: firstHiddenEntry.createdAt,
hiddenEntryIds,
label,
});
@@ -1202,9 +1207,7 @@ export function deriveMessagesTimelineRows(input: {
onlyToolEntries: true,
summary: summarizeToolGroup(visibleGroupedEntries),
summaryKind,
- hasFailure: visibleGroupedEntries.some((entry) =>
- workEntryDisplayIndicatesToolFailure(entry),
- ),
+ hasFailure: workEntryDisplayIndicatesToolFailure(visibleGroupedEntries.at(-1)!),
});
if (expanded) {
for (const [entryIndex, workEntry] of visibleGroupedEntries.entries()) {
@@ -1258,6 +1261,8 @@ export function deriveMessagesTimelineRows(input: {
}
if (hiddenEntries.length > 0) {
+ const latestToolEntry = visibleGroupedEntries.findLast(workLogEntryIsToolLike);
+
nextRows.push({
kind: "work-toggle",
id: `work-toggle:${timelineEntry.id}`,
@@ -1268,9 +1273,10 @@ export function deriveMessagesTimelineRows(input: {
onlyToolEntries: hiddenEntries.every(workLogEntryIsToolLike),
summary: null,
summaryKind: null,
- hasFailure: hiddenEntries.some((entry) =>
- workEntryDisplayIndicatesToolFailure(entry),
- ),
+ hasFailure:
+ latestToolEntry !== undefined &&
+ workEntryDisplayIndicatesToolFailure(latestToolEntry) &&
+ hiddenEntries.some(workEntryDisplayIndicatesToolFailure),
});
}
}
diff --git a/apps/web/src/components/chat/MessagesTimeline.test.tsx b/apps/web/src/components/chat/MessagesTimeline.test.tsx
index 32c126f08415..dc47e840a20b 100644
--- a/apps/web/src/components/chat/MessagesTimeline.test.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.test.tsx
@@ -1,4 +1,5 @@
import { CheckpointRef, EnvironmentId, MessageId, TurnId } from "@t3tools/contracts";
+import { codexFeedbackMessage } from "@t3tools/client-runtime/state/threads";
import { createRef, type ReactNode, type Ref } from "react";
import { renderToStaticMarkup } from "react-dom/server";
import { beforeAll, describe, expect, it, vi } from "vite-plus/test";
@@ -238,6 +239,61 @@ function buildAssistantTimelineEntry(text: string) {
}
describe("MessagesTimeline", () => {
+ it("renders a feedback command and its pending response as normal thread messages", () => {
+ const submission = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: MESSAGE_CREATED_AT,
+ status: "uploading" as const,
+ };
+ const messages = [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ];
+ const markup = renderToStaticMarkup(
+ ({
+ id: message.id,
+ kind: "message" as const,
+ createdAt: message.createdAt,
+ message,
+ }))}
+ />,
+ );
+
+ expect(markup).toContain("/feedback The agent stopped early.");
+ expect(markup).toContain("Sending feedback to OpenAI...");
+ });
+
+ it("renders the returned Codex thread ID in the feedback response", () => {
+ const submission = {
+ id: MessageId.make("feedback-command"),
+ command: "/feedback The agent stopped early.",
+ createdAt: MESSAGE_CREATED_AT,
+ status: "sent" as const,
+ feedbackId: "codex-thread-1",
+ };
+ const messages = [
+ codexFeedbackMessage(submission),
+ codexFeedbackMessage(submission, "assistant"),
+ ];
+ const markup = renderToStaticMarkup(
+