fix: acp_status hides consumed compress calls from PROTECTED list

devlog/2026-07-30_acp-status-consumed-fix/REQ.md

@@ -0,0 +1,23 @@
+# REQ: acp_status shows consumed compress calls as PROTECTED
+
+## Problem
+
+`acp_status` fetches messages directly from the DB via `fetchSessionMessages`,
+bypassing the transform pipeline. `hideConsumedCompressCalls` only modifies
+`output.messages` in the transform hook — the DB retains original compress parts.
+
+Result: consumed (inactive) compress calls show as `[PROTECTED: compress — not compressible]`
+in `acp_status` output, even though they're invisible in the model's actual context.
+This confuses the model into thinking there's much more protected content than
+actually exists, causing misjudgment about what's available for compression.
+
+## Fix
+
+Call `hideConsumedCompressCalls(state, rawMessages)` in `createAcpStatusTool`'s
+execute handler, after `fetchSessionMessages` but before `buildStatusReport`.
+This ensures `acp_status` reflects the same message view the model sees.
+
+## Files
+
+- `lib/compress/status.ts` — import + call `hideConsumedCompressCalls`
+- `tests/acp-status-consumed-fix.test.ts` — 2 tests (consumed hidden, active visible)

devlog/2026-07-30_acp-status-consumed-fix/WORKLOG.md

@@ -0,0 +1,14 @@
+# WORKLOG: acp_status consumed-compress fix
+
+## Implementation
+
+1. Added `hideConsumedCompressCalls` import in `lib/compress/status.ts`
+2. Added `hideConsumedCompressCalls(ctx.state, rawMessages)` call after `fetchSessionMessages`, before `buildStatusReport`
+3. Wrote 2 tests:
+   - "consumed compress calls not shown as PROTECTED after hideConsumedCompressCalls" — verifies the before/after fix behavior
+   - "active compress calls still shown as PROTECTED" — verifies active compress calls survive filtering
+
+## Verification
+
+- typecheck: 0 errors
+- full test suite: 936/936 pass

lib/compress/hide-consumed.ts

@@ -1,52 +1,42 @@
 import type { SessionState, WithParts } from "../state"
 import { hasMeaningfulContent } from "./parts"
 
-/**
- * Hide compress tool-call parts whose blocks have been consumed by another
- * compression (tier escalation or range overlap).
- *
- * This is the compress-as-anchor equivalent of filterCompressedRanges: instead
- * of hiding whole messages covered by active blocks, it hides individual
- * compress tool-call PARTS whose blocks are no longer active. The message shell
- * survives (it may carry other parts); only the consumed compress call disappears.
- *
- * If after removal the message contains only structural parts (step-start,
- * step-finish, reasoning), it is spliced entirely — those carry no useful
- * content once the compress call they wrapped is gone.
- *
- * Block data (full summary, original messages) is preserved in session state and
- * remains recoverable via `decompress`.
- *
- * Returns the number of compress-call parts hidden.
- */
+const KEEP_LAST_ORPHANED = 2
+
 export function hideConsumedCompressCalls(state: SessionState, messages: WithParts[]): number {
-    if (state.prune.messages.blocksById.size === 0) {
-        return 0
-    }
 
-    const consumedMessageIds = new Set<string>()
+    const activeCallIds = new Set<string>()
+    const allBlockCallIds = new Set<string>()
     for (const block of state.prune.messages.blocksById.values()) {
-        if (block.active) continue
-        if (block.deactivatedByUser) continue
-        if (block.deactivatedByUserDeep) continue
-        if (block.deactivatedByBlockId === undefined) continue
-        if (!block.compressMessageId) continue
-        consumedMessageIds.add(block.compressMessageId)
+        if (block.compressCallId) {
+            allBlockCallIds.add(block.compressCallId)
+            if (block.active && !block.deactivatedByUser && !block.deactivatedByUserDeep) {
+                activeCallIds.add(block.compressCallId)
+            }
+        }
     }
 
-    if (consumedMessageIds.size === 0) {
-        return 0
+    const lastOrphanedCallIds: string[] = []
+    for (let i = messages.length - 1; i >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; i--) {
+        const parts = Array.isArray(messages[i]?.parts) ? messages[i]!.parts : []
+        for (let j = parts.length - 1; j >= 0 && lastOrphanedCallIds.length < KEEP_LAST_ORPHANED; j--) {
+            const p = parts[j]!
+            if (p.type === "tool" && p.tool === "compress" && p.callID && !allBlockCallIds.has(p.callID)) {
+                lastOrphanedCallIds.push(p.callID)
+            }
+        }
     }
 
+    const keepCallIds = new Set([...activeCallIds, ...lastOrphanedCallIds])
+
     let hidden = 0
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i]!
-        if (!consumedMessageIds.has(msg.info.id)) continue
-
         const parts = Array.isArray(msg.parts) ? msg.parts : []
         let changed = false
         const remaining = parts.filter((p) => {
             if (p.type === "tool" && p.tool === "compress") {
+                if (p.callID && keepCallIds.has(p.callID)) return true
                 hidden++
                 changed = true
                 return false

lib/compress/status.ts

@@ -12,6 +12,7 @@ import {
     formatCompressibleRanges,
 } from "../messages/inject/utils"
 import { fetchSessionMessages } from "./search"
+import { hideConsumedCompressCalls } from "./hide-consumed"
 import { estimateSystemPromptTokens } from "../token-utils"
 
 const ACP_STATUS_TOOL_DESCRIPTION = `Show context status — overview includes compressible ranges by default.
@@ -607,6 +608,8 @@ export function createAcpStatusTool(factoryCtx: ToolFactoryContext): ReturnType<
                 rawMessages = []
             }
 
+            hideConsumedCompressCalls(ctx.state, rawMessages)
+
             return buildStatusReport(
                 { state: ctx.state, config: ctx.config },
                 rawMessages,

tests/acp-status-consumed-fix.test.ts

@@ -0,0 +1,135 @@
+import { describe, it } from "node:test"
+import assert from "node:assert/strict"
+import { createSessionState } from "../lib/state"
+import type { WithParts, SessionState } from "../lib/state"
+import { assignMessageRefs } from "../lib/message-ids"
+import { buildStatusReport } from "../lib/compress/status"
+import { hideConsumedCompressCalls } from "../lib/compress/hide-consumed"
+
+const SID = "ses-consumed-status"
+
+function makeMsg(
+    id: string,
+    role: "user" | "assistant",
+    text: string,
+    toolParts: unknown[] = [],
+): WithParts {
+    const parts: unknown[] = []
+    if (text) parts.push({ type: "text", text })
+    for (const tp of toolParts) parts.push(tp)
+    return {
+        info: { id, role, sessionID: SID, agent: "a", time: { created: 1 } } as never,
+        parts,
+    } as WithParts
+}
+
+function compressToolPart(callID: string, summary: string, input?: unknown): unknown {
+    return {
+        type: "tool",
+        callID,
+        tool: "compress",
+        state: { status: "completed", input: input ?? { content: [{ summary }] } },
+    }
+}
+
+function setupRefs(state: SessionState, messages: WithParts[]): void {
+    assignMessageRefs(state, messages)
+}
+
+describe("acp_status consumed-compress fix", () => {
+    it("consumed compress calls not shown as PROTECTED after hideConsumedCompressCalls", () => {
+        const state = createSessionState()
+        const messages = [
+            makeMsg("msg-1", "user", "hello"),
+            makeMsg("msg-2", "assistant", "response", [compressToolPart("c-old", "old summary text")]),
+            makeMsg("msg-3", "assistant", "normal text"),
+            makeMsg("msg-4", "assistant", "active compress", [compressToolPart("c-active", "active summary")]),
+        ]
+        setupRefs(state, messages)
+
+        const blocksById = new Map()
+        blocksById.set(1, {
+            blockId: 1,
+            runId: 1,
+            active: false,
+            deactivatedByUser: false,
+            deactivatedByUserDeep: false,
+            deactivatedByBlockId: 2,
+            compressMessageId: "msg-2",
+            compressCallId: "c-old",
+            tier: 1,
+        })
+        blocksById.set(2, {
+            blockId: 2,
+            runId: 2,
+            active: true,
+            deactivatedByUser: false,
+            deactivatedByUserDeep: false,
+            compressMessageId: "msg-4",
+            compressCallId: "c-active",
+            tier: 2,
+        })
+        const activeBlockIds = new Set([2])
+        state.prune = {
+            messages: { blocksById, activeBlockIds, byMessageId: new Map(), activeByAnchorMessageId: new Map() },
+        } as never
+
+        const beforeFix = buildStatusReport(
+            { state, config: { compress: { protectedTools: ["skill", "compress"] } } } as never,
+            messages,
+            { scope: "uncompressed" },
+        )
+        assert.ok(
+            beforeFix.includes("PROTECTED"),
+            "before fix: consumed compress should appear as PROTECTED",
+        )
+
+        hideConsumedCompressCalls(state, messages)
+        const afterFix = buildStatusReport(
+            { state, config: { compress: { protectedTools: ["skill", "compress"] } } } as never,
+            messages,
+            { scope: "uncompressed" },
+        )
+        assert.ok(
+            afterFix.includes("PROTECTED"),
+            "active compress should still be PROTECTED",
+        )
+        assert.ok(
+            !afterFix.includes("old summary text"),
+            "after fix: consumed compress summary should not appear in status output",
+        )
+    })
+
+    it("active compress calls still shown as PROTECTED", () => {
+        const state = createSessionState()
+        const messages = [
+            makeMsg("msg-1", "user", "hello"),
+            makeMsg("msg-2", "assistant", "work"),
+            makeMsg("msg-3", "assistant", "active compress", [compressToolPart("c-active", "my active summary")]),
+        ]
+        setupRefs(state, messages)
+
+        const blocksById = new Map()
+        blocksById.set(1, {
+            blockId: 1,
+            runId: 1,
+            active: true,
+            deactivatedByUser: false,
+            deactivatedByUserDeep: false,
+            compressMessageId: "msg-3",
+            compressCallId: "c-active",
+            tier: 1,
+        })
+        state.prune = {
+            messages: { blocksById, activeBlockIds: new Set([1]), byMessageId: new Map(), activeByAnchorMessageId: new Map() },
+        } as never
+
+        hideConsumedCompressCalls(state, messages)
+        const report = buildStatusReport(
+            { state, config: { compress: { protectedTools: ["skill", "compress"] } } } as never,
+            messages,
+            { scope: "uncompressed" },
+        )
+        assert.ok(report.includes("PROTECTED"), "active compress should still be PROTECTED")
+    })
+})