Pass workflow context through the session compaction path

The TUI wrapped summarize to inject the active workflow, but the pruning
compactor always called summarize with one argument, so mid-workflow
compaction still lost the step contract. Also make the max-anchor fixture
score above the new threshold so the cap test actually exercises it.

Author: TheGreatAxios

src/context-compactor.test.ts

@@ -485,18 +485,26 @@ describe("createPruningCompactor — maxAnchorTurns caps pairing pulls (CL-6906)
     const turns: ConversationTurn[] = [
       makeTurn({ role: "user", content: [{ type: "text", text: "the initiating task" }] }),
     ];
-    // 10 edit_file call/result pairs, well separated from each other and from
-    // the recent window, each independently clearing the anchor threshold.
+    // 10 write-pair call/result turns, well separated from each other and from
+    // the recent window. A single edit_file scores 3 (below the threshold of
+    // 5); two writes on the same assistant turn score 6, so each pair
+    // independently clears the scored-anchor bar.
     for (let i = 0; i < 10; i++) {
       turns.push(
         makeTurn({
           role: "assistant",
           content: [
             {
               type: "tool_call",
-              id: `edit${i}`,
+              id: `edit${i}a`,
               name: "edit_file",
-              arguments: { path: `f${i}.ts` },
+              arguments: { path: `f${i}a.ts` },
+            },
+            {
+              type: "tool_call",
+              id: `edit${i}b`,
+              name: "edit_file",
+              arguments: { path: `f${i}b.ts` },
             },
           ],
         }),
@@ -505,8 +513,13 @@ describe("createPruningCompactor — maxAnchorTurns caps pairing pulls (CL-6906)
           content: [
             {
               type: "tool_result",
-              callId: `edit${i}`,
-              content: [{ type: "text", text: `edited f${i}.ts` }],
+              callId: `edit${i}a`,
+              content: [{ type: "text", text: `edited f${i}a.ts` }],
+            },
+            {
+              type: "tool_result",
+              callId: `edit${i}b`,
+              content: [{ type: "text", text: `edited f${i}b.ts` }],
             },
           ],
         }),

src/session/runtime-assembly.test.ts

@@ -267,4 +267,26 @@ describe("createSessionPruningCompactor", () => {
     expect(typeof pruning.apply).toBe("function");
     expect(typeof llm.apply).toBe("function");
   });
+
+  test("forwards summaryContext to summarize in llm mode", async () => {
+    const ctx = { workflow: { name: "build", stepIndex: 1, total: 3 } };
+    let captured: unknown;
+    const summarize = async (_turns: unknown, c?: unknown) => {
+      captured = c;
+      return "summary";
+    };
+    const llm = createSessionPruningCompactor({
+      compactionMode: "llm",
+      summarize,
+      summaryContext: () => ctx,
+    });
+    const now = Date.now();
+    const turns = Array.from({ length: 8 }, (_, i) => ({
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: [{ type: "text", text: `t${i}` }],
+      timestamp: now,
+    }));
+    await llm.apply(turns as never, { state: {} as never, trigger: "test" });
+    expect(captured).toBe(ctx);
+  });
 });

src/session/runtime-assembly.ts

@@ -41,6 +41,7 @@ import type { Approval, GrantScope } from "../permission/types.js";
 import type { ReasoningEffort } from "../provider/reasoning-effort.js";
 import type { SubAgentProvider } from "../subagent/index.js";
 import { COMPACTOR_KEEP_RECENT_TURNS, createPruningCompactor } from "./compactor.js";
+import type { SummaryContext } from "./summarizer.js";
 import { NOOP_TELEMETRY, type Telemetry } from "../telemetry/index.js";
 
 // ---------------------------------------------------------------------------
@@ -274,7 +275,8 @@ const SESSION_COMPACTOR_SUMMARY_MAX_CHARS = 2500;
 
 export type SessionPruningCompactorArgs = {
   compactionMode: "llm" | "pruning";
-  summarize: (turns: ConversationTurn[]) => Promise<string>;
+  summarize: (turns: ConversationTurn[], ctx?: SummaryContext) => Promise<string>;
+  summaryContext?: () => SummaryContext | undefined;
   telemetry?: Telemetry;
 };
 
@@ -286,6 +288,7 @@ export function createSessionPruningCompactor(
     keepRecentTurns: COMPACTOR_KEEP_RECENT_TURNS,
     summaryMaxChars: SESSION_COMPACTOR_SUMMARY_MAX_CHARS,
     ...(args.compactionMode !== "pruning" ? { summarize: args.summarize } : {}),
+    ...(args.summaryContext ? { summaryContext: args.summaryContext } : {}),
   });
   const telemetry = args.telemetry ?? NOOP_TELEMETRY;
   return {

src/tui/runner.ts

@@ -221,7 +221,7 @@ import {
   skillDirsFromEnabledPlugins,
 } from "../session/runtime-assembly.js";
 import { createAttachmentRehydrateTransform } from "../session/attachment-store.js";
-import { createModelSummarizer } from "../session/summarizer.js";
+import { createModelSummarizer, type SummaryContext } from "../session/summarizer.js";
 import { COMMAND_NAME, ID_PREFIX, LOG_NAMESPACE_ROOT } from "../branding.js";
 import { deliverAgentMessage } from "./deliver-agent-message.js";
 
@@ -1394,23 +1394,20 @@ export async function runTUI(initialConfig: Config): Promise<number> {
 
   // Compaction summarizer: produces a structured, workflow-aware handoff via a
   // one-shot call on the live model, falling back to the deterministic summary
-  // on any failure. The workflow context is read at call time so a compaction
-  // mid-/build or mid-/plan preserves which step we are on.
+  // on any failure. Workflow state is read at compaction time so a pass
+  // mid-/build or mid-/plan still names the active step.
   const compactionSummarize = createModelSummarizer({ getSource: () => liveSource, deps: inferenceDeps });
-  const summarizeForCompaction = (turns: Parameters<typeof compactionSummarize>[0]): Promise<string> => {
+  const summaryContext = (): SummaryContext | undefined => {
     const status = workflowController.status();
-    return compactionSummarize(turns, {
-      ...(status.active
-        ? {
-            workflow: {
-              ...(status.name !== undefined ? { name: status.name } : {}),
-              stepLabel: status.label,
-              stepIndex: status.stepIndex,
-              total: status.total,
-            },
-          }
-        : {}),
-    });
+    if (!status.active) return undefined;
+    return {
+      workflow: {
+        ...(status.name !== undefined ? { name: status.name } : {}),
+        stepLabel: status.label,
+        stepIndex: status.stepIndex,
+        total: status.total,
+      },
+    };
   };
 
   // Mutable reference so the compaction summarize callback reads the live mode
@@ -1441,7 +1438,8 @@ export async function runTUI(initialConfig: Config): Promise<number> {
       compactors: {
         "pruning-compactor": createSessionPruningCompactor({
           compactionMode: liveCompactionMode,
-          summarize: summarizeForCompaction,
+          summarize: compactionSummarize,
+          summaryContext,
           telemetry: liveTelemetry,
         }),
       },