fix: prune context and compact earlier

docs/plans/2026-04-12-context-manager-implementation.md

@@ -0,0 +1,180 @@
+# Context manager stronger pruning and compaction Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Keep live context flatter by pruning whole older turns, compacting earlier, and injecting only lean resume state.
+
+**Architecture:** Extend pruning at the context boundary, keep summary artifacts in snapshot/ledger only, and add an extension-managed early-compaction gate driven by observed context usage. Preserve existing commands and ledger semantics while removing footer status noise.
+
+**Tech Stack:** TypeScript, Node test runner (`tsx --test`), Pi extension hooks
+
+---
+
+### Task 1: Turn-aware pruning and lean resume rendering
+
+**Files:**
+- Modify: `src/prune.ts`
+- Modify: `src/prune.test.ts`
+- Modify: `src/summaries.ts`
+- Modify: `src/summaries.test.ts`
+- Modify: `src/runtime.ts`
+- Modify: `src/runtime.test.ts`
+
+- [ ] **Step 1: Write the failing prune and resume tests**
+
+```ts
+test("pruneContextMessages drops turns older than the kept suffix", () => {
+  const messages = [
+    { role: "user", content: "turn 1" },
+    { role: "assistant", content: "after turn 1" },
+    { role: "user", content: "turn 2" },
+    { role: "assistant", content: "after turn 2" },
+    { role: "user", content: "turn 3" },
+  ];
+
+  const pruned = pruneContextMessages(messages, buildPolicy(2));
+  assert.deepEqual(pruned.map((m) => m.content), ["turn 2", "after turn 2", "turn 3"]);
+});
+
+test("buildResumePacket keeps blocker text after raw handoff sections are removed", () => {
+  const runtime = createContextManagerRuntime({ mode: "balanced", contextWindow: 200_000 });
+  runtime.recordCompactionSummary("## Open questions and blockers\n- Verify /tree replaceInstructions behavior.");
+  assert.match(runtime.buildResumePacket(), /Verify \/tree replaceInstructions behavior/);
+  assert.doesNotMatch(runtime.buildResumePacket(), /## Latest compaction handoff/);
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact && npm test -- src/prune.test.ts src/runtime.test.ts src/summaries.test.ts`
+Expected: FAIL because pruning still keeps old turns and runtime still prepends raw handoff sections.
+
+- [ ] **Step 3: Write the minimal implementation**
+
+```ts
+// src/prune.ts
+// Keep only the last N user-anchored turns.
+// Distill bulky tool results only for kept older turns, never for the newest turn.
+
+// src/summaries.ts
+export function buildResumePacket(ledger: LedgerState): string {
+  return [
+    ...lines("Goal", getActiveItems(ledger, "goal").map((item) => item.text)),
+    ...lines("Current task", getActiveItems(ledger, "activeTask").map((item) => item.text)),
+    ...lines("Constraints", getActiveItems(ledger, "constraint").map((item) => item.text)),
+    ...lines("Key decisions", getActiveItems(ledger, "decision").map((item) => item.text)),
+    ...lines("Open questions / blockers", getActiveItems(ledger, "openQuestion").map((item) => item.text)),
+  ].join("\n").trim();
+}
+
+// src/runtime.ts
+function buildResumePacket() {
+  return renderResumePacket(snapshot.ledger).trim();
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact && npm test -- src/prune.test.ts src/runtime.test.ts src/summaries.test.ts`
+Expected: PASS for the new pruning and lean-resume assertions.
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact
+git add src/prune.ts src/prune.test.ts src/summaries.ts src/summaries.test.ts src/runtime.ts src/runtime.test.ts
+git commit -m "fix: prune turns and slim resume packets"
+```
+
+### Task 2: Context filtering, early compaction, and footer removal
+
+**Files:**
+- Modify: `index.ts`
+- Modify: `src/extension.test.ts`
+
+- [ ] **Step 1: Write the failing extension tests**
+
+```ts
+test("context filters raw compaction and branch summary messages", async () => {
+  const result = await harness.handlers.get("context")?.({
+    type: "context",
+    messages: [
+      { role: "compactionSummary", summary: "## Key Decisions\n- noisy raw handoff", timestamp: 1 },
+      { role: "branchSummary", summary: "# Handoff\n- noisy raw branch", timestamp: 2 },
+      createUserMessage("continue", 3),
+    ],
+  }, harness.ctx);
+
+  assert.ok(result.messages.every((message: any) => message.role !== "compactionSummary" && message.role !== "branchSummary"));
+});
+
+test("turn_end triggers early compaction at red zone without footer status writes", async () => {
+  const harness = createHarness([], { usageTokens: 150_000 });
+  await harness.handlers.get("session_start")?.({ type: "session_start" }, harness.ctx);
+  await harness.handlers.get("turn_end")?.({ type: "turn_end", turnIndex: 1, message: createAssistantMessage("done", 5), toolResults: [] }, harness.ctx);
+  assert.equal(harness.compactions.length, 1);
+  assert.equal(harness.statuses.length, 0);
+});
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact && npm test -- src/extension.test.ts`
+Expected: FAIL because summary messages are still passed through, early compaction is absent, and status writes still occur.
+
+- [ ] **Step 3: Write the minimal implementation**
+
+```ts
+// index.ts
+// - Filter raw compactionSummary / branchSummary messages before pruning.
+// - Remove ctx.ui.setStatus(...) calls.
+// - After observeTokens on turn_end, call ctx.compact() once when snapshot.lastZone is red/compact.
+// - Reset the latch on session_compact or when usage drops below red.
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact && npm test -- src/extension.test.ts`
+Expected: PASS for summary filtering, early compaction, and no-footer assertions.
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact
+git add index.ts src/extension.test.ts
+git commit -m "fix: compact earlier and drop status noise"
+```
+
+### Task 3: Full verification and cleanup
+
+**Files:**
+- Modify: `src/config.ts` (only if zone tightening needs a small recent-turn adjustment)
+- Modify: `src/config.test.ts` (only if policy values change)
+
+- [ ] **Step 1: Run the full test suite**
+
+```bash
+cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact
+npm test
+```
+
+- [ ] **Step 2: If any failures remain, make the minimal fix and rerun**
+
+```ts
+// Only patch the failing behavior surfaced by the full test run.
+// Do not broaden scope beyond pruning, lean resume injection, summary filtering,
+// early compaction, and footer removal.
+```
+
+- [ ] **Step 3: Verify the final green run**
+
+Run: `cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact && npm test`
+Expected: `# fail 0`
+
+- [ ] **Step 4: Commit final cleanup if needed**
+
+```bash
+cd /home/dev/pi-packages/pi-context-manager/.worktree/context-manager-prune-compact
+git add index.ts src/*.ts docs/plans/2026-04-12-context-manager-implementation.md
+git commit -m "test: cover context pressure behavior"
+```