TypeScript
fix(mobile): compact stale Claude threads before sending (#27935)
shivam754e1d1534ce
diff --git a/apps/mobile/src/state/thread-outbox-model.ts b/apps/mobile/src/state/thread-outbox-model.tsindex 6c5da0db209..703d9f8450f 100644--- a/apps/mobile/src/state/thread-outbox-model.ts+++ b/apps/mobile/src/state/thread-outbox-model.ts@@ -56,6 +56,7 @@ export const QueuedThreadMessageSchema = Schema.Struct({attachments: Schema.Array(DraftComposerAttachmentSchema),modelSelection: Schema.optional(ModelSelection),dispatchMode: Schema.optional(Schema.Literals(["auto", "queue", "steer", "restart"])),+ compactBeforeSend: Schema.optional(Schema.Boolean),runtimeMode: Schema.optional(RuntimeMode),interactionMode: Schema.optional(ProviderInteractionMode),creation: Schema.optional(QueuedThreadCreationSchema),@@ -89,6 +90,8 @@ export interface QueuedThreadMessage {readonly interactionMode?: ProviderInteractionModeType;/** Captured at enqueue because draining may occur long after the tap. */readonly dispatchMode?: ComposerDispatchMode;+ /** Sends "When you return"'s `/compact` ahead of the message, which queues behind it. */+ readonly compactBeforeSend?: boolean;readonly creation?: QueuedThreadCreation;readonly createdAt: string;}diff --git a/apps/mobile/src/state/thread-outbox.test.ts b/apps/mobile/src/state/thread-outbox.test.tsindex 8aaf94ffc0d..dbd621004b0 100644--- a/apps/mobile/src/state/thread-outbox.test.ts+++ b/apps/mobile/src/state/thread-outbox.test.ts@@ -329,6 +329,8 @@ describe("thread outbox", () => {},runtimeMode: "approval-required",interactionMode: "plan",+ dispatchMode: "queue",+ compactBeforeSend: true,} satisfies QueuedThreadMessage;expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(selectedMessage))).toEqual(diff --git a/apps/mobile/src/state/thread-task-permissions.test.ts b/apps/mobile/src/state/thread-task-permissions.test.tsindex 0b529e99478..adf72cc6527 100644--- a/apps/mobile/src/state/thread-task-permissions.test.ts+++ b/apps/mobile/src/state/thread-task-permissions.test.ts@@ -333,6 +333,7 @@ describe("mobile handoff preview and submission", () => {auth: { status: "authenticated" as const },availability: "available" as "available" | "unavailable",models: [{ slug: selection.model }],+ slashCommands: [],};const projectOverride = { enabled: false };state.serverConfig = {diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.tsindex 0ea64764e5d..fdd5c710941 100644--- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts+++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts@@ -498,3 +498,52 @@ describe("queued task operation access", () => {},);});++describe("compaction before a queued send", () => {+ const compactTurn = {+ commandId: "command:compact",+ message: {+ messageId: "message:compact",+ role: "user",+ text: "/compact",+ attachments: [],+ idleCompaction: "onReturn",+ },+ dispatchMode: "queue",+ };++ it("queues /compact ahead of the message and resends the same /compact on a retry", async () => {+ setOperateGrant("secondary", true);+ const queued = message({ compactBeforeSend: true, dispatchMode: "queue" });+ await state.manager.enqueue(queued);+ state.start+ .mockResolvedValueOnce(AsyncResult.success({}))+ .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("Socket is not connected"))));+ await runDrain();+ expect(remaining()).toEqual([queued]);++ // A restarted app delivers the persisted message again.+ state.cleanups.splice(0).forEach((cleanup) => cleanup());+ await runDrain();+ expect(state.start.mock.calls.map(([call]) => call.input)).toEqual([+ expect.objectContaining(compactTurn),+ expect.objectContaining({ commandId: "command", dispatchMode: "queue" }),+ expect.objectContaining(compactTurn),+ expect.objectContaining({ commandId: "command", dispatchMode: "queue" }),+ ]);+ expect(remaining()).toEqual([]);+ });++ it("holds the message when its /compact cannot be sent", async () => {+ setOperateGrant("secondary", true);+ const queued = message({ compactBeforeSend: true, dispatchMode: "queue" });+ await state.manager.enqueue(queued);+ state.start.mockResolvedValueOnce(+ AsyncResult.failure(Cause.fail(new Error("Socket is not connected"))),+ );+ await runDrain();+ expect(state.start).toHaveBeenCalledOnce();+ expect(state.start.mock.calls[0]?.[0].input).toMatchObject(compactTurn);+ expect(remaining()).toEqual([queued]);+ });+});diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.tsindex 89d7b68b920..44bd564ef89 100644--- a/apps/mobile/src/state/threadOutboxDelivery.ts+++ b/apps/mobile/src/state/threadOutboxDelivery.ts@@ -16,10 +16,10 @@ import {CommandId,DEFAULT_PROVIDER_INTERACTION_MODE,DEFAULT_RUNTIME_MODE,+ MessageId,managedRuntimeModeDenial,PROVIDER_SEND_TURN_MAX_ATTACHMENTS,type EnvironmentId,- type MessageId,} from "@t3tools/contracts";import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git";import * as Cause from "effect/Cause";@@ -873,6 +873,37 @@ export function createThreadOutboxDelivery(): {settings,currentConfig.providers,);+ if (queuedMessage.compactBeforeSend === true) {+ if (!hasAccess()) return true;+ // Queued, since steering a running turn with a compaction is rejected.+ const compactionResult = await runDeliveryCommand(threadEnvironment.startTurn, {+ environmentId: queuedMessage.environmentId,+ input: {+ commandId: settingsCommandId(queuedMessage, "compact"),+ creationSource: "mobile",+ threadId: queuedMessage.threadId,+ message: {+ messageId: MessageId.make(`${queuedMessage.messageId}:compact`),+ role: "user",+ text: "/compact",+ attachments: [],+ idleCompaction: "onReturn",+ },+ modelSelection: sendSettings.modelSelection,+ runtimeMode: sendSettings.runtimeMode,+ interactionMode: sendSettings.interactionMode,+ createdAt: queuedMessage.createdAt,+ dispatchMode: "queue",+ },+ });+ if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return true;+ const compactionFailure = reportCommandFailure(queuedMessage, compactionResult, "start-turn");+ if (compactionFailure?.action === "retry") return false;+ if (compactionFailure?.action === "restore") {+ return restoreQueuedMessage(persistedMessage, compactionFailure.message);+ }+ if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true;+ }if (!hasAccess()) return true;const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {environmentId: queuedMessage.environmentId,diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.tsindex 700d15213f2..336226cce8b 100644--- a/apps/mobile/src/state/use-thread-composer-state.ts+++ b/apps/mobile/src/state/use-thread-composer-state.ts@@ -3,6 +3,7 @@ import * as Dialog from "../components/ui/Dialog";import { AuthOrchestrationOperateScope } from "@t3tools/contracts";import { readEnvironmentScope } from "./session";import { useAtomValue } from "@effect/atom-react";+import { shouldCompactBeforeSend } from "@t3tools/client-runtime/state/context-window";import { threadRuntimeIsActive } from "@t3tools/client-runtime/state/shell";import type { ThreadCheckpointSummary } from "@t3tools/client-runtime/state/thread-checkpoints";import { resolvePendingHandoff } from "@t3tools/client-runtime/handoff";@@ -661,6 +662,25 @@ export function useThreadComposerState() {: "auto";const metadata = makeQueuedMessageMetadata();+ const compactBeforeSend =+ followUpDispatchMode === null &&+ selectedEnvironmentRuntime?.connectionState === "connected" &&+ selectedThreadProjection !== null &&+ serverConfig != null &&+ shouldCompactBeforeSend({+ projection: selectedThreadProjection.projection,+ visibleTurnItems: selectedThreadVisibleTurnItems,+ selection: modelSelection,+ providers: serverConfig.providers,+ settings: serverConfig.settings,+ text,+ threadIdle:+ !activeThreadBusy &&+ !runlessWorkActive &&+ !isCompacting &&+ selectedThreadQueuedMessages.length === 0,+ now: metadata.createdAt,+ });const messageId = MessageId.make(metadata.messageId);onWillEnqueue?.();clearThreadComposerError(threadKey);@@ -678,7 +698,11 @@ export function useThreadComposerState() {provider,draft.interactionMode ?? thread.interactionMode,),- ...(followUpDispatchMode === null ? {} : { dispatchMode: followUpDispatchMode }),+ ...(compactBeforeSend+ ? { compactBeforeSend, dispatchMode: "queue" as const }+ : followUpDispatchMode === null+ ? {}+ : { dispatchMode: followUpDispatchMode }),createdAt: metadata.createdAt,});clearComposerDraftContent(threadKey, { deferAttachmentCleanup: true });diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.tsindex 4e17fdebf7b..e933abf86b2 100644--- a/apps/web/src/components/ChatView.logic.ts+++ b/apps/web/src/components/ChatView.logic.ts@@ -4,6 +4,7 @@ import {deriveThreadRuntime,} from "@t3tools/client-runtime/state/thread-execution";import { checkpointFileTotals } from "@t3tools/client-runtime/state/thread-checkpoints";+import { COMPACT_COMMAND_PATTERN } from "@t3tools/client-runtime/state/context-window";import { derivePendingBackgroundWork } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";import {latestUnheldRun,@@ -834,10 +835,6 @@ export function shouldShowPlanFollowUpPrompt(input: {);}-// A typed `/compact`, with or without instructions, is already the compaction. Queueing a-// bare one ahead of it would run an uninstructed compaction first and charge for two.-const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s|$)/i;-const sessionDismissedBranchMismatchKeys = new Set<string>();export function dismissBranchMismatchForSession(key: string): void {diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex d1225065aee..3008c471c05 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -314,15 +314,13 @@ import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/Composimport { modelFallbackBannerItem } from "./chat/ComposerUsageLimits";import { ComposerSurface } from "./chat/ComposerSurface";import { resolveThreadSyncPhase } from "../threadSync";-import {- hasAvailableCompactionProvider,- hasDismissedResumeCompaction,- shouldOfferResumeCompaction,-} from "./chat/ContextWindowMeter.logic";+import { hasAvailableCompactionProvider } from "./chat/ContextWindowMeter.logic";import {deriveLatestContextWindowSnapshot,+ hasDismissedResumeCompaction,latestProviderTurnTokenUsage,-} from "../lib/contextWindow";+ shouldOfferResumeCompaction,+} from "@t3tools/client-runtime/state/context-window";import {MOBILE_COMPOSER_VIEW_TRANSITION_NAME,MOBILE_DRAFT_HEADLINE_VIEW_TRANSITION_NAME,diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsxindex 25b7f5ce6f8..95fa71d9532 100644--- a/apps/web/src/components/chat/ChatComposer.tsx+++ b/apps/web/src/components/chat/ChatComposer.tsx@@ -252,7 +252,7 @@ import {resolveComposerDispatchMode,type ComposerDispatchMode,} from "@t3tools/client-runtime/state/composer-dispatch";-import { deriveLatestContextWindowSnapshot } from "../../lib/contextWindow";+import { deriveLatestContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";import {resolveProviderSkillsForCwd,resolveProviderSlashCommandsForCwd,diff --git a/apps/web/src/components/chat/ComposerFooterControls.tsx b/apps/web/src/components/chat/ComposerFooterControls.tsxindex cb5e78c1e8c..6ac13a51428 100644--- a/apps/web/src/components/chat/ComposerFooterControls.tsx+++ b/apps/web/src/components/chat/ComposerFooterControls.tsx@@ -8,7 +8,7 @@ import { createModelSelection } from "@t3tools/shared/model";import { BotIcon, PencilRulerIcon } from "lucide-react";import { type ComponentProps, memo, useId, useRef, useState } from "react";-import type { ContextWindowSnapshot } from "../../lib/contextWindow";+import type { ContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";import { Menu as MenuPrimitive } from "@base-ui/react/menu";import { Menu, MenuPopup, MenuTrigger } from "../ui/menu";import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";diff --git a/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts b/apps/web/src/components/chat/ContextWindowMeter.logic.test.tsindex e8d08570707..c9131276bff 100644--- a/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts+++ b/apps/web/src/components/chat/ContextWindowMeter.logic.test.ts@@ -1,9 +1,9 @@import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";import { describe, expect, it } from "vite-plus/test";import { deriveProviderInstanceEntries } from "../../providerInstances";+import { hasDismissedResumeCompaction } from "@t3tools/client-runtime/state/context-window";import {hasAvailableCompactionProvider,- hasDismissedResumeCompaction,resolveContextWindowModelDisplayName,shouldReserveContextWindowMeter,} from "./ContextWindowMeter.logic";diff --git a/apps/web/src/components/chat/ContextWindowMeter.logic.ts b/apps/web/src/components/chat/ContextWindowMeter.logic.tsindex 5a0911a10a0..1eb9668bc33 100644--- a/apps/web/src/components/chat/ContextWindowMeter.logic.ts+++ b/apps/web/src/components/chat/ContextWindowMeter.logic.ts@@ -1,18 +1,10 @@import type { ModelSelection, ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts";-import {- CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,- COMPACTION_SUGGESTION_MIN_TOKENS,- isClaudeResumeCompactionQuestion,-} from "@t3tools/shared/claudeCompaction";import {resolveSelectableProviderInstanceEntry,type ProviderInstanceEntry,} from "../../providerInstances";import { getDisplayModelName, type ModelEsque } from "./providerIconUtils";-// Fallback TTL: Claude's 1h cache plus slack.-const CLAUDE_RESUME_COMPACTION_FALLBACK_MS = 70 * 60_000;-export function providerSupportsManualCompaction(provider: ProviderInstanceEntry | null | undefined,): boolean {@@ -43,47 +35,6 @@ export function hasAvailableCompactionProvider(input: {);}-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 promptCacheTtlMs?: number | undefined;- readonly now: string;-}): boolean {- if (- input.provider !== "claudeAgent" ||- (input.usedTokens ?? 0) < COMPACTION_SUGGESTION_MIN_TOKENS- ) {- return false;- }-- const updatedAt = Date.parse(input.updatedAt ?? "");- const now = Date.parse(input.now);- return (- Number.isFinite(updatedAt) &&- Number.isFinite(now) &&- now - updatedAt >= (input.promptCacheTtlMs ?? CLAUDE_RESUME_COMPACTION_FALLBACK_MS)- );-}-export function resolveContextWindowModelDisplayName(selection: ModelSelection | null | undefined,modelOptionsByInstance: ReadonlyMap<ProviderInstanceId, ReadonlyArray<ModelEsque>>,diff --git a/apps/web/src/components/chat/ContextWindowMeter.tsx b/apps/web/src/components/chat/ContextWindowMeter.tsxindex e7f4042f53b..9f2c2dbc918 100644--- a/apps/web/src/components/chat/ContextWindowMeter.tsx+++ b/apps/web/src/components/chat/ContextWindowMeter.tsx@@ -1,5 +1,6 @@import { Button } from "../ui/button";-import { type ContextWindowSnapshot, formatContextWindowTokens } from "~/lib/contextWindow";+import type { ContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";+import { formatContextWindowTokens } from "~/lib/contextWindow";import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";import {formatContextWindowCompactionMessage,diff --git a/apps/web/src/components/chat/ThreadDetailsUsage.tsx b/apps/web/src/components/chat/ThreadDetailsUsage.tsxindex 05211d6ace4..f3ee87e1b7f 100644--- a/apps/web/src/components/chat/ThreadDetailsUsage.tsx+++ b/apps/web/src/components/chat/ThreadDetailsUsage.tsx@@ -16,7 +16,8 @@ import type { ReactNode } from "react";import { usePrimarySettings } from "../../hooks/useSettings";import { useNowMinute } from "../../hooks/useNowMinute";-import { type ContextWindowSnapshot, formatContextWindowTokens } from "../../lib/contextWindow";+import type { ContextWindowSnapshot } from "@t3tools/client-runtime/state/context-window";+import { formatContextWindowTokens } from "../../lib/contextWindow";import { cn } from "../../lib/utils";import { formatUpcomingTimestamp } from "../../timestampFormat";import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";diff --git a/apps/web/src/lib/contextWindow.test.ts b/apps/web/src/lib/contextWindow.test.tsindex c27ddd9a046..7d49d24a73f 100644--- a/apps/web/src/lib/contextWindow.test.ts+++ b/apps/web/src/lib/contextWindow.test.ts@@ -11,8 +11,11 @@ import {ThreadId,} from "@t3tools/contracts";import { makeThreadProjectionFixture } from "../test-fixtures";-import { shouldOfferResumeCompaction } from "../components/chat/ContextWindowMeter.logic";-import { deriveLatestContextWindowSnapshot, latestProviderTurnTokenUsage } from "./contextWindow";+import {+ deriveLatestContextWindowSnapshot,+ latestProviderTurnTokenUsage,+ shouldOfferResumeCompaction,+} from "@t3tools/client-runtime/state/context-window";const decodeTokenUsage = Schema.decodeSync(OrchestrationV2ProviderTurnTokenUsage);diff --git a/apps/web/src/lib/contextWindow.ts b/apps/web/src/lib/contextWindow.tsindex 8c449249e03..1cf3eee799b 100644--- a/apps/web/src/lib/contextWindow.ts+++ b/apps/web/src/lib/contextWindow.ts@@ -1,179 +1,3 @@-import type { ThreadStructure, ThreadStructureTurnItem } from "@t3tools/client-runtime/state/shell";-import type {- OrchestrationV2ProviderTurn,- OrchestrationV2ProviderTurnTokenUsage,- OrchestrationV2ProviderThread,- ThreadTokenUsageSnapshot,-} from "@t3tools/contracts";-import * as DateTime from "effect/DateTime";--function asFiniteNumber(value: unknown): number | null {- return typeof value === "number" && Number.isFinite(value) ? value : null;-}--type NullableContextWindowUsage = {- readonly [Key in keyof ThreadTokenUsageSnapshot]: undefined extends ThreadTokenUsageSnapshot[Key]- ? Exclude<ThreadTokenUsageSnapshot[Key], undefined> | null- : ThreadTokenUsageSnapshot[Key];-};--export type ContextWindowSnapshot = NullableContextWindowUsage & {- readonly remainingTokens: number | null;- readonly usedPercentage: number | null;- readonly remainingPercentage: number | null;- readonly updatedAt: string;-};--/** Newest report by timestamp; snapshots order turns by provider thread. */-export function latestProviderTurnTokenUsage(- turns: ReadonlyArray<Pick<OrchestrationV2ProviderTurn, "tokenUsage">>,- projection?: Pick<ThreadStructure, "thread" | "contextTransfers"> | null,- providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage"> | null,-): OrchestrationV2ProviderTurnTokenUsage | null {- let latest: OrchestrationV2ProviderTurnTokenUsage | null = null;- for (const { tokenUsage } of turns) {- if (tokenUsage === undefined) continue;- // Ties go to the later entry, since live upserts append.- if (latest === null || Date.parse(tokenUsage.updatedAt) >= Date.parse(latest.updatedAt)) {- latest = tokenUsage;- }- }- if (latest !== null || projection == null || providerThread?.contextUsage != null) return latest;- const forkedFrom = projection.thread.forkedFrom;- if (forkedFrom?.type !== "run") return null;- return (- projection.contextTransfers.find(- (transfer) =>- transfer.type === "fork" &&- transfer.targetThreadId === projection.thread.id &&- transfer.sourceThreadId === forkedFrom.threadId &&- transfer.sourcePoint.runId === forkedFrom.runId &&- transfer.sourceProviderInstanceId === projection.thread.modelSelection.instanceId &&- (transfer.status === "pending" || transfer.resolution?.strategy === "native_fork"),- )?.sourceTokenUsage ?? null- );-}--export function deriveLatestContextWindowSnapshot(- entries: ReadonlyArray<{- readonly item: ThreadStructureTurnItem;- }>,- liveUsage?: OrchestrationV2ProviderTurnTokenUsage | null,- providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage" | "updatedAt"> | null,-): ContextWindowSnapshot | null {- if (liveUsage != null) {- const usedTokens = Math.max(0, liveUsage.usedTokens);- const maxTokens = liveUsage.maxTokens ?? null;- const usedPercentage =- maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;- const remainingTokens =- maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;- const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;- return {- usedTokens,- totalProcessedTokens: null,- maxTokens,- remainingTokens,- usedPercentage,- remainingPercentage,- inputTokens: liveUsage.inputTokens ?? null,- cachedInputTokens: liveUsage.cachedInputTokens ?? null,- outputTokens: liveUsage.outputTokens ?? null,- reasoningOutputTokens: liveUsage.reasoningOutputTokens ?? null,- lastUsedTokens: null,- lastInputTokens: null,- lastCachedInputTokens: null,- lastOutputTokens: null,- lastReasoningOutputTokens: null,- toolUses: null,- durationMs: null,- compactsAutomatically: true,- autoCompactThreshold: liveUsage.autoCompactThreshold ?? null,- cost: null,- updatedAt: liveUsage.updatedAt,- };- }- const providerUsage = providerThread?.contextUsage;- const providerUsageUpdatedAt = providerThread?.updatedAt;- if (- providerUsage !== null &&- providerUsage !== undefined &&- providerUsageUpdatedAt !== undefined- ) {- const maxTokens = asFiniteNumber(providerUsage.maxTokens);- const usedTokens = providerUsage.usedTokens;- const usedPercentage =- maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;- return {- usedTokens,- totalProcessedTokens: asFiniteNumber(providerUsage.totalProcessedTokens),- maxTokens,- remainingTokens: maxTokens === null ? null : Math.max(0, Math.round(maxTokens - usedTokens)),- usedPercentage,- remainingPercentage: usedPercentage === null ? null : Math.max(0, 100 - usedPercentage),- inputTokens: asFiniteNumber(providerUsage.inputTokens),- cachedInputTokens: asFiniteNumber(providerUsage.cachedInputTokens),- outputTokens: asFiniteNumber(providerUsage.outputTokens),- reasoningOutputTokens: asFiniteNumber(providerUsage.reasoningOutputTokens),- lastUsedTokens: asFiniteNumber(providerUsage.lastUsedTokens),- lastInputTokens: asFiniteNumber(providerUsage.lastInputTokens),- lastCachedInputTokens: asFiniteNumber(providerUsage.lastCachedInputTokens),- lastOutputTokens: asFiniteNumber(providerUsage.lastOutputTokens),- lastReasoningOutputTokens: asFiniteNumber(providerUsage.lastReasoningOutputTokens),- toolUses: asFiniteNumber(providerUsage.toolUses),- durationMs: asFiniteNumber(providerUsage.durationMs),- compactsAutomatically: providerUsage.compactsAutomatically ?? null,- cost: providerUsage.cost ?? null,- autoCompactThreshold: providerUsage.autoCompactThreshold ?? null,- updatedAt: DateTime.formatIso(providerUsageUpdatedAt),- };- }- for (let index = entries.length - 1; index >= 0; index -= 1) {- const entry = entries[index];- if (!entry || entry.item.type !== "compaction") {- continue;- }- const payload = entry.item;- const usedTokens = asFiniteNumber(payload.afterTokenCount);- if (usedTokens === null || usedTokens < 0) {- continue;- }-- const maxTokens = null;- const usedPercentage =- maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;- const remainingTokens =- maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;- const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;-- return {- usedTokens,- totalProcessedTokens: asFiniteNumber(payload.beforeTokenCount),- maxTokens,- remainingTokens,- usedPercentage,- remainingPercentage,- inputTokens: null,- cachedInputTokens: null,- outputTokens: null,- reasoningOutputTokens: null,- lastUsedTokens: null,- lastInputTokens: null,- lastCachedInputTokens: null,- lastOutputTokens: null,- lastReasoningOutputTokens: null,- toolUses: null,- durationMs: null,- compactsAutomatically: true,- autoCompactThreshold: null,- cost: null,- updatedAt: DateTime.formatIso(payload.startedAt ?? payload.updatedAt),- };- }-- return null;-}-export function formatContextWindowTokens(value: number | null): string {if (value === null || !Number.isFinite(value)) {return "0";diff --git a/docs/user/providers-claude.md b/docs/user/providers-claude.mdindex 7ba6d356d4a..1eef74a8642 100644--- a/docs/user/providers-claude.md+++ b/docs/user/providers-claude.md@@ -60,7 +60,8 @@ When you return to a large thread after Claude's prompt cache expires, a**Compact** chip with the thread's token count showsnext to the send button. While it is on, Enter summarizes the history first, thensends your message. Click the chip to switch it to **Keep** and keep the full-history for that message. The cache lasts about an hour on a Claude+history for that message. The mobile app shows no chip: an eligible message sent+from it summarizes first. The cache lasts about an hour on a Claudesubscription and 5 minutes with an API key, Bedrock, or Vertex. See [commands and skills](./composer.md#commands-and-skills) for usingcomposer commands.diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.jsonindex 21a5ae568de..270640bc4ae 100644--- a/packages/client-runtime/package.json+++ b/packages/client-runtime/package.json@@ -355,6 +355,10 @@"types": "./src/state/composerDispatch.ts","default": "./src/state/composerDispatch.ts"},+ "./state/context-window": {+ "types": "./src/state/contextWindow.ts",+ "default": "./src/state/contextWindow.ts"+ },"./state/thread-subagents": {"types": "./src/state/threadSubagents.ts","default": "./src/state/threadSubagents.ts"diff --git a/packages/client-runtime/src/handoff.ts b/packages/client-runtime/src/handoff.tsindex c4e7b095952..48a12274293 100644--- a/packages/client-runtime/src/handoff.ts+++ b/packages/client-runtime/src/handoff.ts@@ -24,7 +24,7 @@ export type HandoffTimelineRun = Pick<export type HandoffEndpoints = ReturnType<typeof resolveHandoffEndpoints>;export function resolvePendingHandoff(- projection: ThreadStructure | null | undefined,+ projection: Pick<ThreadStructure, "runs" | "visibleTurnItems"> | null | undefined,selection: ModelSelection | null | undefined,providers: ReadonlyArray<ServerProvider>,): HandoffEndpoints | null {diff --git a/packages/client-runtime/src/state/contextWindow.test.ts b/packages/client-runtime/src/state/contextWindow.test.tsnew file mode 100644index 00000000000..3f1a4d3d419--- /dev/null+++ b/packages/client-runtime/src/state/contextWindow.test.ts@@ -0,0 +1,264 @@+import {+ DEFAULT_SERVER_SETTINGS,+ ProviderDriverKind,+ ProviderInstanceId,+ ProviderThreadId,+ RunId,+ type ServerProvider,+ type ServerSettings,+} from "@t3tools/contracts";+import {+ CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,+ formatClaudeResumeCompactionQuestion,+} from "@t3tools/shared/claudeCompaction";+import * as DateTime from "effect/DateTime";+import { describe, expect, it } from "vite-plus/test";++import { shouldCompactBeforeSend } from "./contextWindow.ts";+import type { ThreadStructure } from "./models.ts";+import { v2Projection } from "./orchestrationV2TestFixtures.ts";++const claude = ProviderInstanceId.make("claudeAgent");+const claudeWork = ProviderInstanceId.make("claude_work");+const claudeOtherHome = ProviderInstanceId.make("claude_other_home");+const codex = ProviderInstanceId.make("codex");+const lastTurnAt = "2026-10-30T14:23:02.000Z";+const returnedAt = "2026-10-30T23:03:21.000Z";++function sendInput(+ overrides: {+ readonly usedTokens?: number;+ readonly promptCacheTtlMs?: number;+ readonly now?: string;+ readonly settings?: Partial<ServerSettings>;+ readonly source?: ProviderInstanceId;+ readonly selected?: ProviderInstanceId;+ readonly onlyEarlierConversationUsage?: boolean;+ readonly unstartedFork?: boolean;+ readonly slashCommands?: ReadonlyArray<string>;+ readonly dismissed?: boolean;+ readonly heldQueue?: boolean;+ readonly pendingRequest?: boolean;+ readonly onlyCompactMessages?: boolean;+ readonly promptOutsideWindow?: boolean;+ readonly text?: string;+ readonly threadIdle?: boolean;+ } = {},+) {+ const source = overrides.source ?? claude;+ const sourceSelection = {+ instanceId: source,+ model: source === codex ? "gpt-5.4" : "claude-opus-4-6",+ };+ const providers = [+ { instanceId: claude, driver: "claudeAgent", groupKey: "claude:~/.claude" },+ { instanceId: claudeWork, driver: "claudeAgent", groupKey: "claude:~/.claude" },+ { instanceId: claudeOtherHome, driver: "claudeAgent", groupKey: "claude:~/.claude-other" },+ { instanceId: codex, driver: "codex", groupKey: "codex:~/.codex" },+ ].map(({ instanceId, driver, groupKey }) => ({+ instanceId,+ driver: ProviderDriverKind.make(driver),+ continuation: { groupKey },+ slashCommands: (overrides.slashCommands ?? ["compact"]).map((name) => ({ name })),+ })) as unknown as ReadonlyArray<ServerProvider>;+ const providerThread = (id: string) => ({+ id: ProviderThreadId.make(id),+ driver: providers.find((provider) => provider.instanceId === source)!.driver,+ providerInstanceId: source,+ contextUsage: null,+ updatedAt: DateTime.makeUnsafe(lastTurnAt),+ });+ const visibleTurnItems =+ overrides.promptOutsideWindow === true+ ? [{ item: { type: "assistant_message", text: "Build fixed" } }]+ : [+ {+ item: {+ type: "user_message",+ runId: RunId.make("run-1"),+ text: overrides.onlyCompactMessages === true ? "/compact" : "Fix the build",+ attachments: [],+ },+ },+ ];+ const projection = {+ ...v2Projection,+ thread: {+ ...v2Projection.thread,+ providerInstanceId: source,+ modelSelection: sourceSelection,+ activeProviderThreadId: ProviderThreadId.make("provider-thread-current"),+ },+ providerThreads: [+ providerThread("provider-thread-earlier"),+ providerThread("provider-thread-current"),+ ],+ providerTurns: [+ {+ providerThreadId: ProviderThreadId.make(+ overrides.onlyEarlierConversationUsage === true+ ? "provider-thread-earlier"+ : "provider-thread-current",+ ),+ tokenUsage: {+ usedTokens: overrides.usedTokens ?? 293_611,+ updatedAt: lastTurnAt,+ ...(overrides.promptCacheTtlMs === undefined+ ? {}+ : { promptCacheTtlMs: overrides.promptCacheTtlMs }),+ },+ },+ ],+ runs: [+ {+ id: RunId.make("run-1"),+ ordinal: 1,+ providerInstanceId: source,+ modelSelection: sourceSelection,+ status: "completed",+ startedAt: "2026-10-30T14:20:00.000Z",+ contextHandoffId: null,+ },+ ...(overrides.heldQueue === true+ ? [{ id: RunId.make("queued-run"), status: "queued", queueHeld: true, startedAt: null }]+ : []),+ ],+ runtimeRequests: [+ ...(overrides.dismissed === true+ ? [+ {+ kind: "user_input",+ status: "resolved",+ answers: {+ [formatClaudeResumeCompactionQuestion({+ ageMinutes: 90,+ estimatedTokens: 250_000,+ })]: CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,+ },+ },+ ]+ : []),+ ...(overrides.pendingRequest === true ? [{ kind: "approval", status: "pending" }] : []),+ ],+ visibleTurnItems,+ } as unknown as ThreadStructure;+ if (overrides.unstartedFork === true) {+ Object.assign(projection, {+ thread: {+ ...projection.thread,+ activeProviderThreadId: null,+ forkedFrom: { type: "run", threadId: "source-thread", runId: "source-run" },+ },+ runs: [],+ providerThreads: [],+ providerTurns: [],+ contextTransfers: [+ {+ type: "fork",+ targetThreadId: projection.thread.id,+ sourceThreadId: "source-thread",+ sourcePoint: { runId: "source-run" },+ sourceProviderInstanceId: source,+ status: "pending",+ sourceTokenUsage: { usedTokens: 293_611, updatedAt: lastTurnAt },+ },+ ],+ });+ }+ const selected = overrides.selected ?? claude;+ return {+ projection,+ visibleTurnItems: visibleTurnItems as never,+ selection: {+ instanceId: selected,+ model: selected === codex ? "gpt-5.4" : "claude-opus-4-6",+ },+ providers,+ settings: { ...DEFAULT_SERVER_SETTINGS, ...overrides.settings },+ text: overrides.text ?? "back again",+ threadIdle: overrides.threadIdle ?? true,+ now: overrides.now ?? returnedAt,+ };+}++describe("shouldCompactBeforeSend", () => {+ it.each([+ { name: "a stale Claude thread over 200K", expected: true },+ {+ name: "when the original prompt is outside the loaded window",+ promptOutsideWindow: true,+ expected: true,+ },+ {+ name: "when the environment compacts before the cache expires",+ settings: { idleCompaction: "beforeCacheExpires" },+ expected: true,+ },+ {+ name: "past a reported TTL shorter than the fallback",+ promptCacheTtlMs: 5 * 60_000,+ now: "2026-10-30T14:30:00.000Z",+ expected: true,+ },+ { name: "within the fallback TTL", now: "2026-10-30T15:23:02.000Z", expected: false },+ { name: "under 200K", usedTokens: 150_000, expected: false },+ { name: "with idle compaction off", settings: { idleCompaction: "off" }, expected: false },+ {+ name: "with the Claude instance overriding idle compaction to off",+ settings: {+ idleCompaction: "onReturn",+ providerInstances: {+ [claude]: {+ driver: ProviderDriverKind.make("claudeAgent"),+ config: { idleCompaction: "off" },+ },+ },+ },+ expected: false,+ },+ { name: "on a Codex thread", source: codex, selected: codex, expected: false },+ {+ name: "after switching a stale Codex thread to Claude",+ source: codex,+ selected: claude,+ expected: false,+ },+ {+ name: "after switching to a Claude instance that continues the conversation",+ selected: claudeWork,+ expected: true,+ },+ {+ name: "after switching to a Claude instance with another home",+ selected: claudeOtherHome,+ expected: false,+ },+ {+ name: "when only an earlier conversation reported usage",+ onlyEarlierConversationUsage: true,+ expected: false,+ },+ { name: "an unstarted fork resuming its source instance", unstartedFork: true, expected: true },+ {+ name: "an unstarted fork selecting another Claude home",+ unstartedFork: true,+ selected: claudeOtherHome,+ expected: false,+ },+ { name: "for a provider without /compact", slashCommands: [], expected: false },+ {+ name: "after Claude's resume dialog was answered Don't ask again",+ dismissed: true,+ expected: false,+ },+ { name: "while the queue is held", heldQueue: true, expected: false },+ { name: "while a request waits for an answer", pendingRequest: true, expected: false },+ { name: "while the thread is working", threadIdle: false, expected: false },+ { name: "with no conversation but /compact", onlyCompactMessages: true, expected: false },+ { name: "for a typed /compact", text: "/compact keep the plan", expected: false },+ ] as const)("$name", ({ name: _name, expected, ...overrides }) => {+ expect(shouldCompactBeforeSend(sendInput(overrides as Parameters<typeof sendInput>[0]))).toBe(+ expected,+ );+ });+});diff --git a/packages/client-runtime/src/state/contextWindow.ts b/packages/client-runtime/src/state/contextWindow.tsnew file mode 100644index 00000000000..66c48807465--- /dev/null+++ b/packages/client-runtime/src/state/contextWindow.ts@@ -0,0 +1,319 @@+import {+ resolveIdleCompaction,+ type ModelSelection,+ type OrchestrationV2ProviderTurn,+ type OrchestrationV2ProviderTurnTokenUsage,+ type OrchestrationV2ProviderThread,+ type ServerProvider,+ type ServerSettings,+ type ThreadTokenUsageSnapshot,+} from "@t3tools/contracts";+import {+ CLAUDE_RESUME_COMPACTION_NEVER_ANSWER,+ COMPACTION_SUGGESTION_MIN_TOKENS,+ isClaudeResumeCompactionQuestion,+} from "@t3tools/shared/claudeCompaction";+import * as DateTime from "effect/DateTime";++import { resolvePendingHandoff } from "../handoff.ts";+import type { ThreadStructure, ThreadStructureTurnItem } from "./models.ts";++// Fallback TTL: Claude's 1h cache plus slack.+const CLAUDE_RESUME_COMPACTION_FALLBACK_MS = 70 * 60_000;++// A typed `/compact`, with or without instructions, is already the compaction. Queueing a+// bare one ahead of it would run an uninstructed compaction first and charge for two.+export const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s|$)/i;++function asFiniteNumber(value: unknown): number | null {+ return typeof value === "number" && Number.isFinite(value) ? value : null;+}++type NullableContextWindowUsage = {+ readonly [Key in keyof ThreadTokenUsageSnapshot]: undefined extends ThreadTokenUsageSnapshot[Key]+ ? Exclude<ThreadTokenUsageSnapshot[Key], undefined> | null+ : ThreadTokenUsageSnapshot[Key];+};++export type ContextWindowSnapshot = NullableContextWindowUsage & {+ readonly remainingTokens: number | null;+ readonly usedPercentage: number | null;+ readonly remainingPercentage: number | null;+ readonly updatedAt: string;+};++/** Newest report by timestamp; snapshots order turns by provider thread. */+export function latestProviderTurnTokenUsage(+ turns: ReadonlyArray<Pick<OrchestrationV2ProviderTurn, "tokenUsage">>,+ projection?: Pick<ThreadStructure, "thread" | "contextTransfers"> | null,+ providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage"> | null,+): OrchestrationV2ProviderTurnTokenUsage | null {+ let latest: OrchestrationV2ProviderTurnTokenUsage | null = null;+ for (const { tokenUsage } of turns) {+ if (tokenUsage === undefined) continue;+ // Ties go to the later entry, since live upserts append.+ if (latest === null || Date.parse(tokenUsage.updatedAt) >= Date.parse(latest.updatedAt)) {+ latest = tokenUsage;+ }+ }+ if (latest !== null || projection == null || providerThread?.contextUsage != null) return latest;+ const forkedFrom = projection.thread.forkedFrom;+ if (forkedFrom?.type !== "run") return null;+ return (+ projection.contextTransfers.find(+ (transfer) =>+ transfer.type === "fork" &&+ transfer.targetThreadId === projection.thread.id &&+ transfer.sourceThreadId === forkedFrom.threadId &&+ transfer.sourcePoint.runId === forkedFrom.runId &&+ transfer.sourceProviderInstanceId === projection.thread.modelSelection.instanceId &&+ (transfer.status === "pending" || transfer.resolution?.strategy === "native_fork"),+ )?.sourceTokenUsage ?? null+ );+}++export function deriveLatestContextWindowSnapshot(+ entries: ReadonlyArray<{+ readonly item: ThreadStructureTurnItem;+ }>,+ liveUsage?: OrchestrationV2ProviderTurnTokenUsage | null,+ providerThread?: Pick<OrchestrationV2ProviderThread, "contextUsage" | "updatedAt"> | null,+): ContextWindowSnapshot | null {+ if (liveUsage != null) {+ const usedTokens = Math.max(0, liveUsage.usedTokens);+ const maxTokens = liveUsage.maxTokens ?? null;+ const usedPercentage =+ maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;+ const remainingTokens =+ maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;+ const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;+ return {+ usedTokens,+ totalProcessedTokens: null,+ maxTokens,+ remainingTokens,+ usedPercentage,+ remainingPercentage,+ inputTokens: liveUsage.inputTokens ?? null,+ cachedInputTokens: liveUsage.cachedInputTokens ?? null,+ outputTokens: liveUsage.outputTokens ?? null,+ reasoningOutputTokens: liveUsage.reasoningOutputTokens ?? null,+ lastUsedTokens: null,+ lastInputTokens: null,+ lastCachedInputTokens: null,+ lastOutputTokens: null,+ lastReasoningOutputTokens: null,+ toolUses: null,+ durationMs: null,+ compactsAutomatically: true,+ autoCompactThreshold: liveUsage.autoCompactThreshold ?? null,+ cost: null,+ updatedAt: liveUsage.updatedAt,+ };+ }+ const providerUsage = providerThread?.contextUsage;+ const providerUsageUpdatedAt = providerThread?.updatedAt;+ if (+ providerUsage !== null &&+ providerUsage !== undefined &&+ providerUsageUpdatedAt !== undefined+ ) {+ const maxTokens = asFiniteNumber(providerUsage.maxTokens);+ const usedTokens = providerUsage.usedTokens;+ const usedPercentage =+ maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;+ return {+ usedTokens,+ totalProcessedTokens: asFiniteNumber(providerUsage.totalProcessedTokens),+ maxTokens,+ remainingTokens: maxTokens === null ? null : Math.max(0, Math.round(maxTokens - usedTokens)),+ usedPercentage,+ remainingPercentage: usedPercentage === null ? null : Math.max(0, 100 - usedPercentage),+ inputTokens: asFiniteNumber(providerUsage.inputTokens),+ cachedInputTokens: asFiniteNumber(providerUsage.cachedInputTokens),+ outputTokens: asFiniteNumber(providerUsage.outputTokens),+ reasoningOutputTokens: asFiniteNumber(providerUsage.reasoningOutputTokens),+ lastUsedTokens: asFiniteNumber(providerUsage.lastUsedTokens),+ lastInputTokens: asFiniteNumber(providerUsage.lastInputTokens),+ lastCachedInputTokens: asFiniteNumber(providerUsage.lastCachedInputTokens),+ lastOutputTokens: asFiniteNumber(providerUsage.lastOutputTokens),+ lastReasoningOutputTokens: asFiniteNumber(providerUsage.lastReasoningOutputTokens),+ toolUses: asFiniteNumber(providerUsage.toolUses),+ durationMs: asFiniteNumber(providerUsage.durationMs),+ compactsAutomatically: providerUsage.compactsAutomatically ?? null,+ cost: providerUsage.cost ?? null,+ autoCompactThreshold: providerUsage.autoCompactThreshold ?? null,+ updatedAt: DateTime.formatIso(providerUsageUpdatedAt),+ };+ }+ for (let index = entries.length - 1; index >= 0; index -= 1) {+ const entry = entries[index];+ if (!entry || entry.item.type !== "compaction") {+ continue;+ }+ const payload = entry.item;+ const usedTokens = asFiniteNumber(payload.afterTokenCount);+ if (usedTokens === null || usedTokens < 0) {+ continue;+ }++ const maxTokens = null;+ const usedPercentage =+ maxTokens !== null && maxTokens > 0 ? Math.min(100, (usedTokens / maxTokens) * 100) : null;+ const remainingTokens =+ maxTokens !== null ? Math.max(0, Math.round(maxTokens - usedTokens)) : null;+ const remainingPercentage = usedPercentage !== null ? Math.max(0, 100 - usedPercentage) : null;++ return {+ usedTokens,+ totalProcessedTokens: asFiniteNumber(payload.beforeTokenCount),+ maxTokens,+ remainingTokens,+ usedPercentage,+ remainingPercentage,+ inputTokens: null,+ cachedInputTokens: null,+ outputTokens: null,+ reasoningOutputTokens: null,+ lastUsedTokens: null,+ lastInputTokens: null,+ lastCachedInputTokens: null,+ lastOutputTokens: null,+ lastReasoningOutputTokens: null,+ toolUses: null,+ durationMs: null,+ compactsAutomatically: true,+ autoCompactThreshold: null,+ cost: null,+ updatedAt: DateTime.formatIso(payload.startedAt ?? payload.updatedAt),+ };+ }++ return null;+}++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 promptCacheTtlMs?: number | undefined;+ readonly now: string;+}): boolean {+ if (+ input.provider !== "claudeAgent" ||+ (input.usedTokens ?? 0) < COMPACTION_SUGGESTION_MIN_TOKENS+ ) {+ return false;+ }++ const updatedAt = Date.parse(input.updatedAt ?? "");+ const now = Date.parse(input.now);+ return (+ Number.isFinite(updatedAt) &&+ Number.isFinite(now) &&+ now - updatedAt >= (input.promptCacheTtlMs ?? CLAUDE_RESUME_COMPACTION_FALLBACK_MS)+ );+}++/**+ * Whether a plain send into an idle thread compacts it first, as web's composer does under+ * "When you return". Web reads the same state for its "Compact and send" button. A send that+ * hands off to another conversation starts that one fresh, so only the resumed one counts.+ */+export function shouldCompactBeforeSend(input: {+ readonly projection: Pick<+ ThreadStructure,+ | "thread"+ | "contextTransfers"+ | "providerThreads"+ | "providerTurns"+ | "runtimeRequests"+ | "runs"+ | "visibleTurnItems"+ >;+ readonly visibleTurnItems: ReadonlyArray<{ readonly item: ThreadStructureTurnItem }>;+ readonly selection: ModelSelection;+ readonly providers: ReadonlyArray<ServerProvider>;+ readonly settings: Pick<+ ServerSettings,+ "providerInstances" | "compactIdleThreads" | "idleCompaction"+ >;+ readonly text: string;+ readonly threadIdle: boolean;+ readonly now: string;+}): boolean {+ const { projection } = input;+ const provider = input.providers.find((entry) => entry.instanceId === input.selection.instanceId);+ if (+ provider === undefined ||+ !input.threadIdle ||+ COMPACT_COMMAND_PATTERN.test(input.text) ||+ resolveIdleCompaction(input.settings, provider.instanceId) === "off" ||+ !provider.slashCommands.some((command) => command.name === "compact") ||+ resolvePendingHandoff(projection, input.selection, input.providers) !== null ||+ projection.runtimeRequests.some((request) => request.status === "pending") ||+ projection.runs.some((run) => run.status === "queued" && run.queueHeld === true) ||+ (!input.visibleTurnItems.some(+ ({ item }) =>+ item.type === "user_message" &&+ (item.text.trim().toLowerCase() !== "/compact" || item.attachments.length > 0),+ ) &&+ !projection.runs.some(+ (run) =>+ run.status !== "rolled_back" &&+ run.startedAt !== null &&+ !input.visibleTurnItems.some(+ ({ item }) => item.type === "user_message" && item.runId === run.id,+ ),+ )) ||+ hasDismissedResumeCompaction(+ projection.runtimeRequests+ .filter((request) => request.kind === "user_input" && request.status === "resolved")+ .map((request) => ({ kind: "user-input.resolved", payload: { answers: request.answers } })),+ )+ ) {+ return false;+ }+ const activeProviderThreadId = projection.thread.activeProviderThreadId;+ const providerThread = projection.providerThreads.find(+ (thread) => thread.id === activeProviderThreadId,+ );+ const liveUsage = latestProviderTurnTokenUsage(+ projection.providerTurns.filter((turn) => turn.providerThreadId === activeProviderThreadId),+ input.selection.instanceId === projection.thread.modelSelection.instanceId ? projection : null,+ providerThread,+ );+ const contextWindow = deriveLatestContextWindowSnapshot(+ input.visibleTurnItems,+ liveUsage,+ providerThread,+ );+ return (+ contextWindow !== null &&+ shouldOfferResumeCompaction({+ provider: provider.driver,+ usedTokens: contextWindow.usedTokens,+ updatedAt: contextWindow.updatedAt,+ promptCacheTtlMs: liveUsage?.promptCacheTtlMs,+ now: input.now,+ })+ );+}