fix(boundary): unfreeze /ctx-recomp from a stale open tool arc too

The trigger-path fix (df5a76a4) staleness-gated open arcs in the normal boundary
resolver, but the manual-full-recomp branch still selected the FIRST open arc
at/after offset as protectedTailStart. So the same interrupted bash call at the
tail head that froze the historian also froze /ctx-recomp (the user's manual
escape hatch): protectedTailStart=offset -> zero eligible range -> recomp rebuilds
nothing.

Apply the same recent-window staleness gate to manual-full-recomp: derive the
cutoff from findSuffixStartForTokens(deriveProtectedTailTokenTarget(usage:0).N)
and require an open arc to be >= cutoff before it can hold back the recomp. A
stale/dead open arc older than the window is ignored; only a genuine in-flight
call in the live window is protected. Regression test added.

Surfaced by the post-fix oracle re-review (it verified the trigger-path fix
correct at both sites but flagged this unchanged path as a must-fix).

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/plugin/src/hooks/magic-context/protected-tail-boundary.test.ts

@@ -347,6 +347,51 @@ describe("protected-tail boundary integration", () => {
         }
     });
 
+    it("manual-full-recomp is not frozen by a stale (dead) open tool arc at offset", () => {
+        // The same interrupted bash call that froze the trigger path must not
+        // freeze /ctx-recomp (the user's manual escape hatch): a dead open arc
+        // older than the recent window is ignored, so recomp gets a full
+        // eligible range to rebuild.
+        useBoundaryTempDataHome("protected-tail-recomp-dead-arc-");
+        const sessionId = "ses-recomp-dead-open-arc";
+        const messages: Array<{ id: string; role: string; parts: unknown[] }> = [];
+        messages.push({
+            id: "m-dead-bash",
+            role: "assistant",
+            parts: [
+                {
+                    type: "tool",
+                    callID: "toolu_dead",
+                    tool: "bash",
+                    state: { status: "running", input: { command: "sleep 999" } },
+                },
+            ],
+        });
+        for (let i = 1; i <= 8; i++) {
+            messages.push({
+                id: `m-conv-${i}`,
+                role: i % 2 === 1 ? "user" : "assistant",
+                parts: [{ type: "text", text: `conversation turn ${i} `.repeat(800) }],
+            });
+        }
+        const opencodeDb = createBoundaryOpenCodeDb(sessionId, messages);
+        const db = createContextDb();
+        try {
+            const snapshot = resolveOpenCodeProtectedTailBoundary({
+                db,
+                sessionId,
+                mode: "manual-full-recomp",
+                contextLimit: 64_000,
+                executeThresholdPercentage: 65,
+                usageSource: "manual-none",
+            });
+            expect(snapshot.eligibleEndOrdinal).toBeGreaterThan(snapshot.offset);
+        } finally {
+            closeQuietly(db);
+            closeQuietly(opencodeDb);
+        }
+    });
+
     it("bails out when a boundary snapshot's eligible raw range changes", () => {
         useBoundaryTempDataHome("protected-tail-stale-");
         const sessionId = "ses-stale-boundary";

packages/plugin/src/hooks/magic-context/protected-tail-boundary.ts

@@ -373,8 +373,23 @@ export function resolveProtectedTailBoundary(
 
     if (ctx.mode === "manual-full-recomp") {
         const arcs = buildToolArcs(messages);
+        // Staleness gate (mirrors the trigger path): only the current in-flight
+        // call — an open arc within the live recent window — may hold back a full
+        // recomp. A stale/interrupted open arc (its result will never arrive)
+        // must NOT block /ctx-recomp; otherwise the same dead invocation that
+        // froze the historian also freezes the user's manual escape hatch.
+        const recompTarget = deriveProtectedTailTokenTarget({
+            contextLimit: ctx.contextLimit,
+            executeThresholdPercentage: ctx.executeThresholdPercentage,
+            usagePercentage: 0,
+            triggerBudget: ctx.triggerBudget,
+        });
+        const recentOpenArcCutoff = index.findSuffixStartForTokens(recompTarget.N);
         const firstOpenArc = arcs.find(
-            (arc) => arc.resOrdinal === null && arc.invOrdinal >= offset,
+            (arc) =>
+                arc.resOrdinal === null &&
+                arc.invOrdinal >= offset &&
+                arc.invOrdinal >= recentOpenArcCutoff,
         );
         const protectedTailStart = firstOpenArc?.invOrdinal ?? rawMessageCount + 1;
         const rawRangeFingerprint = computeRawRangeFingerprint(