fix(clients): ignore stale compaction after session stops

apps/mobile/src/state/use-thread-composer-state.ts

@@ -327,6 +327,7 @@ export function useThreadComposerState() {
     ? sessionCompactionMutation.scopeKey
     : null;
   const sessionCompactionBlocksSubmission = isSessionCompactionSubmissionBlocked({
+    hasActiveScope: sessionCompactionScope !== null,
     current: selectedThreadCompaction,
     activity: activitySessionCompaction,
     compactPending:

apps/web/src/components/chat/ChatComposer.tsx

@@ -1288,6 +1288,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
       ? authoritativeSessionCompaction.snapshot
       : activitySessionCompaction;
   const sessionCompactionBlocksSubmission = isSessionCompactionSubmissionBlocked({
+    hasActiveScope: sessionCompactionScopeKey !== null,
     current: sessionCompaction,
     activity: activitySessionCompaction,
     compactPending:

packages/client-runtime/src/state/contextCompaction.test.ts

@@ -133,35 +133,51 @@ describe("session compaction state", () => {
   });
 
   it("blocks composer submission for every active compaction status", () => {
-    expect(isSessionCompactionInProgress({ status: "starting" })).toBe(true);
-    expect(isSessionCompactionInProgress({ status: "compacting" })).toBe(true);
-    expect(isSessionCompactionInProgress({ status: "abort-requested" })).toBe(true);
+    for (const status of ["starting", "compacting", "abort-requested"] as const) {
+      expect(isSessionCompactionInProgress({ status })).toBe(true);
+      expect(
+        isSessionCompactionSubmissionBlocked({
+          hasActiveScope: true,
+          current: { status: "idle" },
+          activity: { status },
+          compactPending: false,
+        }),
+      ).toBe(true);
+    }
     expect(isSessionCompactionInProgress({ status: "idle" })).toBe(false);
     expect(isSessionCompactionInProgress(null)).toBe(false);
 
     expect(
       isSessionCompactionSubmissionBlocked({
-        current: { status: "idle" },
-        activity: { status: "starting" },
-        compactPending: false,
-      }),
-    ).toBe(true);
-    expect(
-      isSessionCompactionSubmissionBlocked({
+        hasActiveScope: true,
         current: { status: "idle" },
         activity: { status: "idle" },
         compactPending: true,
       }),
     ).toBe(true);
     expect(
       isSessionCompactionSubmissionBlocked({
+        hasActiveScope: true,
         current: { status: "idle" },
         activity: { status: "idle" },
         compactPending: false,
       }),
     ).toBe(false);
   });
 
+  it("ignores stale compaction state after the session stops", () => {
+    for (const compactPending of [false, true]) {
+      expect(
+        isSessionCompactionSubmissionBlocked({
+          hasActiveScope: false,
+          current: { status: "compacting" },
+          activity: { status: "compacting" },
+          compactPending,
+        }),
+      ).toBe(false);
+    }
+  });
+
   it("accepts only successful mutations superseded by authoritative activity", () => {
     expect(
       isAcceptedSessionCompactionMutationResult({

packages/client-runtime/src/state/contextCompaction.ts

@@ -101,13 +101,15 @@ export const isSessionCompactionInProgress = (
   snapshot?.status === "abort-requested";
 
 export const isSessionCompactionSubmissionBlocked = (input: {
+  readonly hasActiveScope: boolean;
   readonly current: Pick<SessionCompactionSnapshot, "status"> | null | undefined;
   readonly activity: Pick<SessionCompactionSnapshot, "status"> | null | undefined;
   readonly compactPending: boolean;
 }): boolean =>
-  input.compactPending ||
-  isSessionCompactionInProgress(input.activity) ||
-  isSessionCompactionInProgress(input.current);
+  input.hasActiveScope &&
+  (input.compactPending ||
+    isSessionCompactionInProgress(input.activity) ||
+    isSessionCompactionInProgress(input.current));
 
 export const canStartSessionCompaction = (
   provider: Pick<ServerProvider, "featureCapabilities"> | null | undefined,