perf(plugin): scan past tagless wire leaders when deriving the tag floor

deriveTagLoadFloor scopes both hot-path tag scans (tagger initFromDb + the
compartment trigger's token scans) to tag_number >= floor. It derived the floor
from the leading wire message ids via getMinMessageTagNumberForRawId, which
matches ONLY a message's :p/:file tags — never its tool tags (those key on the
callId). After a compaction marker the wire head is frequently a run of tagless
messages: the synthetic m[0]/m[1] leaders plus tool-only assistant turns. The
old logic capped at the first 8 ID-BEARING probes and took their MIN, so a
tagless head exhausted the budget on NULLs → Infinity → floor 0 → the full
~100k-tag scan the floor exists to avoid. Live-observed as an oscillating ~66ms
compartmentTrigger that flipped to ~6ms only on passes whose head happened to
start with a tagged message.

Fix: keep probing PAST NULL leaders until 8 resolve (bounded by 64 probes so a
fully-tagless head still falls back to floor 0 rather than scanning the wire),
and widen the safety margin by 64 per leader skipped before the first hit — a
skipped tool-only leader's tool tags sit just below the first :p tag we land on,
so the wider margin keeps them inside the floor. The floor still only ever errs
LOW (loads a few extra tags, never drops a live-wire tag), so the §N§ wire bytes
and the trigger decision stay identical. Adds a one-line "tag floor: 0
(full-scan fallback)" health log so the fallback can't hide as silent latency.

Author: ualtinok

packages/plugin/src/features/magic-context/storage-tags.ts

@@ -928,37 +928,67 @@ export function getMinMessageTagNumberForRawId(
     return isMinTagNumberRow(row) && typeof row.m === "number" ? row.m : null;
 }
 
-// Number of leading wire messages probed to derive the load-scoping floor, and
-// the margin subtracted from the resulting min tag number. A LOWER floor only
-// ever loads MORE tags (strictly safe — it can never exclude an in-wire tag);
-// the margin absorbs a tagged leading compaction-summary, near-boundary tool
-// straddles, and minor reordering at the wire head.
-export const TAGGER_FLOOR_SCAN_MESSAGES = 8;
+// Floor derivation tunables. A LOWER floor only ever loads MORE tags (strictly
+// safe — it can never exclude an in-wire tag); the margin absorbs a tagged
+// leading compaction-summary, near-boundary tool straddles, and reordering at
+// the wire head.
+//   SCAN_HITS    — stop once this many leading messages RESOLVE to a real tag
+//                  (we MIN across them to absorb head reordering).
+//   MAX_PROBES   — hard cap on probes so a fully-ghost/tool-only head can't make
+//                  us scan the whole wire; exhausting it → floor 0 (full scan).
+//   SAFETY_MARGIN     — base margin subtracted from the resolved min.
+//   PER_SKIP_MARGIN   — extra margin per LEADER SKIPPED before the first hit.
+export const TAGGER_FLOOR_SCAN_MESSAGES = 8; // SCAN_HITS
+export const TAGGER_FLOOR_MAX_PROBES = 64;
 export const TAGGER_FLOOR_SAFETY_MARGIN = 256;
+export const TAGGER_FLOOR_PER_SKIP_MARGIN = 64;
 
 /**
  * Derive the tagger/scan load-scoping floor from the leading wire message ids:
- * the minimum message/file tag number across the first
- * `TAGGER_FLOOR_SCAN_MESSAGES` id-bearing ids, minus `TAGGER_FLOOR_SAFETY_MARGIN`
- * (clamped to 0). Shared by the tagger's `initFromDb` and the compartment
- * trigger's tag scans so both scope to the same live-wire range. Returns 0 when
- * nothing is tagged yet → callers fall back to the full-session scan.
+ * roughly the minimum message/file tag number across the leading messages,
+ * minus a safety margin (clamped to 0). Shared by the tagger's `initFromDb` and
+ * the compartment trigger's tag scans so both scope to the same live-wire range.
+ * Returns 0 when nothing resolves → callers fall back to the full-session scan.
+ *
+ * `getMinMessageTagNumberForRawId` matches ONLY a message's `:p`/`:file` tags,
+ * never its tool tags (those key on the callId). So the wire head — which after
+ * a compaction marker is frequently a run of tool-only assistant turns and/or
+ * tagless ghost/synthetic leaders — returns all-NULL. The old code capped at the
+ * first 8 ID-BEARING probes and took their MIN, so such a head exhausted the
+ * budget on NULLs → Infinity → floor 0 → the full ~100k-tag scan we are trying
+ * to avoid (the live ~66ms compartmentTrigger oscillation).
+ *
+ * Fix: keep probing PAST NULL leaders until SCAN_HITS messages resolve (bounded
+ * by MAX_PROBES). A skipped tool-only leader's tool tags sit just BELOW the
+ * first `:p` tag we land on, so we widen the margin by PER_SKIP_MARGIN for every
+ * leader skipped before the first hit — the floor still only ever errs LOWER
+ * (loads a few extra tags), never higher (never drops a live-wire tag).
  */
 export function deriveTagLoadFloor(
     db: Database,
     sessionId: string,
     rawIds: Iterable<string | null | undefined>,
 ): number {
     let min = Number.POSITIVE_INFINITY;
-    let scanned = 0;
+    let probes = 0;
+    let hits = 0;
+    let skippedBeforeFirstHit = 0;
     for (const rawId of rawIds) {
         if (typeof rawId !== "string" || rawId.length === 0) continue;
+        if (probes >= TAGGER_FLOOR_MAX_PROBES) break;
+        probes++;
         const m = getMinMessageTagNumberForRawId(db, sessionId, rawId);
-        if (m !== null && m < min) min = m;
-        if (++scanned >= TAGGER_FLOOR_SCAN_MESSAGES) break;
+        if (m === null) {
+            if (hits === 0) skippedBeforeFirstHit++;
+            continue;
+        }
+        if (m < min) min = m;
+        if (++hits >= TAGGER_FLOOR_SCAN_MESSAGES) break;
     }
     if (!Number.isFinite(min)) return 0;
-    return Math.max(0, min - TAGGER_FLOOR_SAFETY_MARGIN);
+    const margin =
+        TAGGER_FLOOR_SAFETY_MARGIN + skippedBeforeFirstHit * TAGGER_FLOOR_PER_SKIP_MARGIN;
+    return Math.max(0, min - margin);
 }
 
 // Single source-of-truth column list for SELECTs that produce TagEntry.

packages/plugin/src/features/magic-context/tagger-scoped-load.test.ts

@@ -214,6 +214,43 @@ describe("deriveTagLoadFloor", () => {
         expect(deriveTagLoadFloor(db, s, [null, undefined, "", "msg_a"])).toBe(0);
         expect(deriveTagLoadFloor(db, s, ["msg_untagged"])).toBe(0);
     });
+
+    it("scans PAST tagless leaders (ghost/tool-only) to the first real :p tag", () => {
+        // Reproduces the live regression: after a compaction marker the wire head
+        // is a run of tool-only / tagless ghost messages with NO :p/:file tag, so
+        // the old 8-id-probe MIN exhausted on NULLs → floor 0 → full scan.
+        const s = "ses-1";
+        // 3 tagless leaders (no message/file tag), then the first real one at 9000.
+        insertMessageTag(db, s, "msg_real:p0", 9000);
+        const floor = deriveTagLoadFloor(db, s, [
+            "msg_ghost1",
+            "msg_tool2",
+            "msg_tool3",
+            "msg_real",
+        ]);
+        // Resolves (not 0). Base margin 256 + 3 skipped * 64 = 448 → 9000 - 448.
+        expect(floor).toBe(9000 - (256 + 3 * 64));
+    });
+
+    it("widens the margin per skipped leader so skipped tool tags stay included", () => {
+        const s = "ses-1";
+        // One skipped leader → margin 256 + 64 = 320.
+        insertMessageTag(db, s, "msg_real:p0", 1000);
+        expect(deriveTagLoadFloor(db, s, ["msg_ghost", "msg_real"])).toBe(1000 - 320);
+        // Zero skipped (first id resolves) → base margin only.
+        expect(deriveTagLoadFloor(db, s, ["msg_real"])).toBe(1000 - 256);
+    });
+
+    it("stops at MAX_PROBES on a fully-tagless head → floor 0 (full-scan fallback)", () => {
+        const s = "ses-1";
+        // A real tag exists but only PAST the probe cap; 100 tagless leaders first.
+        insertMessageTag(db, s, "msg_real:p0", 5000);
+        const head: string[] = [];
+        for (let i = 0; i < 100; i++) head.push(`msg_ghost${i}`);
+        head.push("msg_real");
+        // The first 64 probes are all NULL → break before reaching msg_real → 0.
+        expect(deriveTagLoadFloor(db, s, head)).toBe(0);
+    });
 });
 
 describe("scoped tag-token scans (boundary + trigger pre-gate)", () => {

packages/plugin/src/hooks/magic-context/transform.ts

@@ -1063,6 +1063,17 @@ export function createTransform(deps: TransformDeps) {
         // deriving it here keeps both tag scans scoped on every pass (those
         // anchor-miss passes were the residual ~90ms full-scan regression).
         const taggerFloor = deriveTaggerLoadFloor(messages, sessionId, db);
+        // floor 0 = no leading wire message resolved to a tag → BOTH tag scans
+        // (tagger initFromDb + the trigger's token scans) fall back to the full
+        // ~O(session) load. On a large session that's the ~70ms compartmentTrigger
+        // we are trying to avoid, so surface it as a one-line health signal rather
+        // than letting it hide as silent latency.
+        if (taggerFloor === 0 && messages.length > 0) {
+            sessionLog(
+                sessionId,
+                `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`,
+            );
+        }
 
         let triggerBoundarySnapshot: ProtectedTailBoundarySnapshot | undefined;
         if (fullFeatureMode && historianRunnable && !sessionMeta.compartmentInProgress) {