@tekmidian/pai 0.50.0 → 0.51.1

package/docs/commands/audit.md

@@ -58,7 +58,7 @@ Cache/input/output token split for a session transcript (default: newest)
 
 | Option | Description | Default |
 |--------|-------------|---------|
-| `--ctx-threshold <n>` | Per-turn context size above which a turn counts as 'above threshold' (default 200000) |  |
+| `--ctx-threshold <n>` | Override the derived compaction trigger (default: derived from the session's own window and measured/configured trigger — see 'window'/'trigger' in the report header) |  |
 | `--history [n]` | List first-turn context of the newest n sessions in this project's transcript directory (default 20) |  |
 | `--turn <n>` | Attribute API call n's context growth to the transcript lines injected since the previous call |  |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekmidian/pai",
-  "version": "0.50.0",
+  "version": "0.51.1",
   "description": "PAI Knowledge OS — Personal AI Infrastructure with federated memory and project management",
   "type": "module",
   "main": "dist/index.mjs",

package/src/hooks/ts/lib/context-fill.test.ts

@@ -11,6 +11,7 @@ import {
   formatContextFill,
   statuslineStateFilePath,
   contextFillThresholds,
+  configuredTrigger,
   resolveAutocompactPct,
   measureCompactionTrigger,
   modelFamily,
@@ -269,40 +270,33 @@ function readingAt(windowSize: number, source: ContextFillReading["source"] = "s
 }
 
 describe("contextFillThresholds", () => {
-  // Fixture requested verbatim: override=80 explicit, 1M window → warmUp
-  // 684,000. That does not hold up: effectiveTrigger = 1,000,000 * 80/100 =
-  // 800,000, and warmUp = effectiveTrigger - 100,000 = 700,000 by the stated
-  // formula — 684,000 has no derivation from these inputs, and an EXPLICIT
-  // override of 80 cannot legitimately produce a different effectiveTrigger
-  // than an ABSENT override that defaults to the same 80, which the next
-  // fixture below requires to be 700,000. Asserting 684,000 here would only
-  // be possible by special-casing "override was explicitly set" versus
-  // "override defaulted", which the formula gives no basis for. Testing the
-  // formula as specified instead: both explicit-80 and absent-defaults-to-80
-  // must agree, and they do.
-  it("derives warmup from windowSize * (override/100) - 100k, for an explicit override", () => {
+  // effectiveTrigger = configuredTrigger(windowSize, pct) = pct/100 *
+  // (windowSize - 20,000) — NOT windowSize * pct/100. An EXPLICIT override
+  // of 80 and an ABSENT override that defaults to the same 80 must agree,
+  // and they do: both give 784,000 on a 1M window, warmUp 684,000.
+  it("derives warmup from configuredTrigger(windowSize, override) - 100k, for an explicit override", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" });
-    expect(t.effectiveTriggerTokens).toBe(800_000);
-    expect(t.warmupTokens).toBe(700_000);
+    expect(t.effectiveTriggerTokens).toBe(784_000);
+    expect(t.warmupTokens).toBe(684_000);
   });
 
   it("derives the same effective trigger when the override is absent (defaults to 80)", () => {
     const t = contextFillThresholds(readingAt(1_000_000), {});
     expect(t.autocompactPct).toBe(80);
-    expect(t.effectiveTriggerTokens).toBe(800_000);
-    expect(t.warmupTokens).toBe(700_000);
+    expect(t.effectiveTriggerTokens).toBe(784_000);
+    expect(t.warmupTokens).toBe(684_000);
   });
 
   it("scales down correctly for a 200k window with the override absent", () => {
     const t = contextFillThresholds(readingAt(200_000), {});
-    expect(t.effectiveTriggerTokens).toBe(160_000);
-    expect(t.warmupTokens).toBe(60_000);
+    expect(t.effectiveTriggerTokens).toBe(144_000);
+    expect(t.warmupTokens).toBe(44_000);
   });
 
   it("computes refresh 40k and immediate 15k below the effective trigger", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" });
-    expect(t.refreshTokens).toBe(760_000);
-    expect(t.immediateTokens).toBe(785_000);
+    expect(t.refreshTokens).toBe(744_000);
+    expect(t.immediateTokens).toBe(769_000);
   });
 
   it("marks the window confirmed only for a statusline-sourced reading", () => {
@@ -313,8 +307,15 @@ describe("contextFillThresholds", () => {
   it("clamps a threshold that would go negative instead of returning it", () => {
     // A tiny window where even the trigger itself is below the warmup margin.
     const t = contextFillThresholds(readingAt(50_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" });
-    expect(t.effectiveTriggerTokens).toBe(40_000);
-    expect(t.warmupTokens).toBe(0); // 40,000 - 100,000 would be negative
+    expect(t.effectiveTriggerTokens).toBe(24_000); // 0.8 * (50,000 - 20,000)
+    expect(t.warmupTokens).toBe(0); // 24,000 - 100,000 would be negative
+  });
+});
+
+describe("configuredTrigger", () => {
+  it("is pct/100 * (windowSize - 20,000), not windowSize * pct/100", () => {
+    expect(configuredTrigger(1_000_000, 80)).toBe(784_000);
+    expect(configuredTrigger(200_000, 80)).toBe(144_000);
   });
 });
 
@@ -570,8 +571,8 @@ describe("contextFillThresholds — trigger source", () => {
   it("reports triggerSource 'configured' and falls back to the env chain when there is no measured value", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" }, { measuredTrigger: null });
     expect(t.triggerSource).toBe("configured");
-    expect(t.effectiveTriggerTokens).toBe(800_000);
-    expect(t.warmupTokens).toBe(700_000);
+    expect(t.effectiveTriggerTokens).toBe(784_000);
+    expect(t.warmupTokens).toBe(684_000);
   });
 
   it("falls back to configured when cwd is given but the project has no compaction history (real scan, empty fixture)", () => {
@@ -583,7 +584,7 @@ describe("contextFillThresholds — trigger source", () => {
         measuredTrigger: measureCompactionTrigger(cwd, projectsDir),
       });
       expect(t.triggerSource).toBe("configured");
-      expect(t.effectiveTriggerTokens).toBe(800_000);
+      expect(t.effectiveTriggerTokens).toBe(784_000);
     } finally {
       rmSync(projectsDir, { recursive: true, force: true });
     }
@@ -600,27 +601,27 @@ describe("contextFillThresholds — trigger source", () => {
 
   it("CLAMPS a stale-HIGH measured value down to the configured one — the real CaseLeaf case", () => {
     // measured=998,267 (this project's real, but stale, most-recent trigger)
-    // configured=800,000 (80% of a 1,000,000 window)
+    // configured=784,000 (80% of a 1,000,000 window, platform formula)
     const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 998_267 });
     expect(t.measuredTriggerTokens).toBe(998_267);
-    expect(t.configuredTriggerTokens).toBe(800_000);
+    expect(t.configuredTriggerTokens).toBe(784_000);
     expect(t.triggerSource).toBe("measured-clamped");
-    expect(t.effectiveTriggerTokens).toBe(800_000); // min(998267, 800000)
-    expect(t.warmupTokens).toBe(700_000); // fires well before the real ~784,000 boundary
+    expect(t.effectiveTriggerTokens).toBe(784_000); // min(998267, 784000)
+    expect(t.warmupTokens).toBe(684_000);
   });
 
   it("uses the measured value directly when it is LOWER than configured — no clamp needed", () => {
-    // measured=784,000, configured=800,000 -> measured wins, tighter warm-up.
-    const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 784_000 });
+    // measured=700,000, configured=784,000 -> measured wins, tighter warm-up.
+    const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 700_000 });
     expect(t.triggerSource).toBe("measured");
-    expect(t.effectiveTriggerTokens).toBe(784_000);
-    expect(t.warmupTokens).toBe(684_000);
+    expect(t.effectiveTriggerTokens).toBe(700_000);
+    expect(t.warmupTokens).toBe(600_000);
   });
 
   it("uses measured directly when it exactly equals configured (boundary case, not clamped)", () => {
-    const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 800_000 });
+    const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 784_000 });
     expect(t.triggerSource).toBe("measured");
-    expect(t.effectiveTriggerTokens).toBe(800_000);
+    expect(t.effectiveTriggerTokens).toBe(784_000);
   });
 
   it("reports both raw values on the result even when one of them wasn't used, so the clamp is visible", () => {
@@ -628,7 +629,7 @@ describe("contextFillThresholds — trigger source", () => {
     // Both numbers are on the object — a caller can see what was measured
     // AND what was configured, not just the winner.
     expect(t.measuredTriggerTokens).toBe(998_267);
-    expect(t.configuredTriggerTokens).toBe(800_000);
+    expect(t.configuredTriggerTokens).toBe(784_000);
   });
 });
 
@@ -642,36 +643,113 @@ describe("contextFillThresholds — trigger source", () => {
 // ---------------------------------------------------------------------------
 
 describe("contextFillThresholds — 2026-09-20 regime change (override 80 -> 20)", () => {
-  it("measured 784k + configured 200k (override=20, 1M window) -> clamps to 200k", () => {
+  it("measured 784k + configured 196k (override=20, 1M window) -> clamps to 196k", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "20" }, { measuredTrigger: 784_000 });
-    expect(t.configuredTriggerTokens).toBe(200_000);
+    expect(t.configuredTriggerTokens).toBe(196_000); // 0.2 * (1,000,000 - 20,000)
     expect(t.triggerSource).toBe("measured-clamped");
-    expect(t.effectiveTriggerTokens).toBe(200_000);
-    expect(t.warmupTokens).toBe(100_000); // 200,000 - 100,000
+    expect(t.effectiveTriggerTokens).toBe(196_000);
+    expect(t.warmupTokens).toBe(96_000); // 196,000 - 100,000
   });
 
-  it("measured 784k + configured 800k (override=80, 1M window) -> measured wins at 784k", () => {
+  it("measured 784k + configured 784k (override=80, 1M window) -> measured wins at 784k", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" }, { measuredTrigger: 784_000 });
-    expect(t.configuredTriggerTokens).toBe(800_000);
+    expect(t.configuredTriggerTokens).toBe(784_000);
     expect(t.triggerSource).toBe("measured");
     expect(t.effectiveTriggerTokens).toBe(784_000);
   });
 
-  it("measured null + configured 200k (override=20, no compaction history yet) -> 200k", () => {
+  it("measured null + configured 196k (override=20, no compaction history yet) -> 196k", () => {
     const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "20" }, { measuredTrigger: null });
     expect(t.triggerSource).toBe("configured");
-    expect(t.effectiveTriggerTokens).toBe(200_000);
+    expect(t.effectiveTriggerTokens).toBe(196_000);
   });
 
-  it("measured 784k + override unset (defaults to 80, configured 800k) -> measured wins at 784k", () => {
+  it("measured 784k + override unset (defaults to 80, configured 784k) -> measured wins at 784k", () => {
     const t = contextFillThresholds(readingAt(1_000_000), {}, { measuredTrigger: 784_000 });
     expect(t.autocompactPct).toBe(80);
-    expect(t.configuredTriggerTokens).toBe(800_000);
+    expect(t.configuredTriggerTokens).toBe(784_000);
     expect(t.triggerSource).toBe("measured");
     expect(t.effectiveTriggerTokens).toBe(784_000);
   });
 });
 
+// ---------------------------------------------------------------------------
+// measureCompactionTrigger — admissibility filter (Fault 1, 2026-09-20):
+// samples from a different override regime must not win just because they
+// are numerically <= the CURRENT configured trigger. A compaction that
+// fired far below the current configured trigger came from a lower
+// override or a smaller window; it is discarded, not averaged in.
+// ---------------------------------------------------------------------------
+
+describe("measureCompactionTrigger — other-regime samples are discarded", () => {
+  it("discards all samples below half of configured and falls back to configured (measured=null, source configured)", () => {
+    const projectsDir = mkdtempSync(join(tmpdir(), "pai-measured-trigger-test-"));
+    const cwd = "/fake/project/other-regime-all-discarded";
+    const projectDir = join(projectsDir, encodeForFixture(cwd));
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(
+      join(projectDir, "a.jsonl"),
+      [
+        compactBoundaryLine(196_765, "2026-09-20T13:10:00.000Z", "u1"),
+        compactBoundaryLine(195_075, "2026-09-20T15:00:00.000Z", "u2"),
+        compactBoundaryLine(197_902, "2026-09-20T19:00:00.000Z", "u3"),
+      ].join("\n") + "\n"
+    );
+    try {
+      // configured = configuredTrigger(1,000,000, 80) = 784,000; floor = 392,000.
+      const measured = measureCompactionTrigger(cwd, projectsDir, undefined, 784_000);
+      expect(measured).toBeNull();
+
+      const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" }, { measuredTrigger: measured });
+      expect(t.triggerSource).toBe("configured");
+      expect(t.effectiveTriggerTokens).toBe(784_000);
+    } finally {
+      rmSync(projectsDir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps admissible samples and discards only the other-regime one (measured=780,000, source measured)", () => {
+    const projectsDir = mkdtempSync(join(tmpdir(), "pai-measured-trigger-test-"));
+    const cwd = "/fake/project/other-regime-partial";
+    const projectDir = join(projectsDir, encodeForFixture(cwd));
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(
+      join(projectDir, "a.jsonl"),
+      [
+        compactBoundaryLine(780_000, "2026-09-19T09:00:00.000Z", "u1"),
+        compactBoundaryLine(790_000, "2026-09-19T10:00:00.000Z", "u2"),
+        compactBoundaryLine(195_000, "2026-09-20T15:00:00.000Z", "u3"), // other-regime, discarded
+      ].join("\n") + "\n"
+    );
+    try {
+      const measured = measureCompactionTrigger(cwd, projectsDir, undefined, 784_000);
+      expect(measured).toBe(780_000);
+
+      const t = contextFillThresholds(readingAt(1_000_000), { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80" }, { measuredTrigger: measured });
+      expect(t.triggerSource).toBe("measured");
+      expect(t.effectiveTriggerTokens).toBe(780_000);
+    } finally {
+      rmSync(projectsDir, { recursive: true, force: true });
+    }
+  });
+
+  it("applies no filter at all when configuredTriggerTokens is omitted (back-compat with the raw scan)", () => {
+    const projectsDir = mkdtempSync(join(tmpdir(), "pai-measured-trigger-test-"));
+    const cwd = "/fake/project/no-filter";
+    const projectDir = join(projectsDir, encodeForFixture(cwd));
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(
+      join(projectDir, "a.jsonl"),
+      compactBoundaryLine(195_000, "2026-09-20T15:00:00.000Z", "u1") + "\n"
+    );
+    try {
+      expect(measureCompactionTrigger(cwd, projectsDir)).toBe(195_000);
+    } finally {
+      rmSync(projectsDir, { recursive: true, force: true });
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Foreign-model transcripts — a headless worker on another provider (a
 // different context window) shares the project folder; its compactions must

package/src/hooks/ts/lib/context-fill.ts

@@ -294,7 +294,8 @@ export function formatContextFill(reading: ContextFillReading): FillDisplay {
 // The configured chain — env override, then a default — is the fallback,
 // used ONLY when a project has no compaction history yet:
 //
-//   effectiveTrigger = measured ?? (windowSize * (override ?? 80) / 100)
+//   effectiveTrigger = measured ?? configuredTrigger(windowSize, override ?? 80)
+//   configuredTrigger(windowSize, pct) = pct/100 * (windowSize - 20,000)
 //
 // DEFAULT IS 80, NOT 100, WHEN NOTHING IS KNOWN. 100 was considered — it
 // matches the FIRST regime above — and rejected: the costs are asymmetric.
@@ -313,6 +314,17 @@ export function formatContextFill(reading: ContextFillReading): FillDisplay {
 // waiting for one.
 export const DEFAULT_AUTOCOMPACT_PCT = 80;
 
+/**
+ * The platform's actual compaction trigger for a window/pct pair. NOT
+ * windowSize * pct/100 — that formula gives 800,000 on 1M/80 and 160,000 on
+ * 200k/80, but the platform fires at pct/100 * (windowSize - 20,000):
+ * 784,000 and 144,000, measured on every compact_boundary on this machine,
+ * 2026-09-20 (see the module comment above).
+ */
+export function configuredTrigger(windowSize: number, pct: number): number {
+  return Math.round((pct / 100) * (windowSize - 20_000));
+}
+
 /** How many of the most recent compact_boundary events to consider, and to
  *  take the minimum of. */
 const MEASURED_TRIGGER_SAMPLE_SIZE = 3;
@@ -575,26 +587,57 @@ export function selectedCompactionSamples(
 
 /**
  * The measured compaction trigger for a project, or null when it has no
- * compaction history yet (a brand-new project, or one whose transcripts
- * this process cannot read). Minimum of the most recent
- * MEASURED_TRIGGER_SAMPLE_SIZE DISTINCT compact_boundary events, ordered by
- * the events' own timestamps across every transcript the project has
- * (live and archived) — see the module comment above for why minimum, not
- * mean, and readCompactBoundarySamples for why "distinct" and "own
- * timestamp" both matter (a file-mtime-ordered, non-deduplicated version of
- * this returned a stale pre-regime-change trigger on real project data).
+ * compaction history yet (a brand-new project, one whose transcripts this
+ * process cannot read, or one whose only recent samples belong to a
+ * different override regime — see the admissibility filter below).
+ * Minimum of the most recent MEASURED_TRIGGER_SAMPLE_SIZE DISTINCT
+ * compact_boundary events, ordered by the events' own timestamps across
+ * every transcript the project has (live and archived) — see the module
+ * comment above for why minimum, not mean, and readCompactBoundarySamples
+ * for why "distinct" and "own timestamp" both matter (a file-mtime-ordered,
+ * non-deduplicated version of this returned a stale pre-regime-change
+ * trigger on real project data).
+ *
+ * When `configuredTriggerTokens` is given, a sample is admissible only when
+ * preTokens >= 0.5 * configuredTriggerTokens — a compaction that fired far
+ * below the currently configured trigger came from a lower override or a
+ * smaller window, a different regime than the one in force now, and must
+ * not drag the trigger down with it. Real case, 2026-09-20:
+ * CLAUDE_AUTOCOMPACT_PCT_OVERRIDE was 20 for seven hours, this project
+ * compacted three times at ~195k-198k under it, then the override went
+ * back to 80 (configured ~784k) — those three samples are inadmissible and
+ * must be discarded, not averaged into the new regime's trigger, or the
+ * handover would fire at ~155k for days until three fresh ~784k
+ * compactions pushed them out on their own.
  */
 export function measureCompactionTrigger(
   cwd: string,
   projectsDir: string = CLAUDE_PROJECTS_DIR,
-  configPath?: string
+  configPath?: string,
+  configuredTriggerTokens?: number
 ): number | null {
   const samples = selectedCompactionSamples(cwd, projectsDir, configPath);
   if (samples.length === 0) return null;
-  const trigger = Math.min(...samples.map((s) => s.preTokens));
+
+  let admissible = samples;
+  if (configuredTriggerTokens !== undefined) {
+    const floor = 0.5 * configuredTriggerTokens;
+    admissible = samples.filter((s) => s.preTokens >= floor);
+    const discarded = samples.length - admissible.length;
+    if (discarded > 0) {
+      console.error(
+        `[context-fill] discarded ${discarded} compaction sample(s) as other-regime for ${cwd} ` +
+        `(preTokens below ${Math.round(floor)}, half of configured=${configuredTriggerTokens}): ` +
+        samples.filter((s) => s.preTokens < floor).map((s) => `${s.preTokens}@${s.timestamp}`).join(", ")
+      );
+    }
+    if (admissible.length === 0) return null;
+  }
+
+  const trigger = Math.min(...admissible.map((s) => s.preTokens));
   console.error(
     `[context-fill] measured trigger for ${cwd}: ${trigger} (minimum of ` +
-    samples.map((s) => `${s.preTokens}@${s.timestamp}`).join(", ") + ")"
+    admissible.map((s) => `${s.preTokens}@${s.timestamp}`).join(", ") + ")"
   );
   return trigger;
 }
@@ -717,12 +760,12 @@ export function contextFillThresholds(
 ): ContextFillThresholds {
   const windowConfirmed = reading.source === "statusline";
   const autocompactPct = resolveAutocompactPct(env);
-  const configuredTriggerTokens = Math.round(reading.windowSize * (autocompactPct / 100));
+  const configuredTriggerTokens = configuredTrigger(reading.windowSize, autocompactPct);
 
   const measuredTriggerTokens = opts.measuredTrigger !== undefined
     ? opts.measuredTrigger
     : opts.cwd
-      ? measureCompactionTrigger(opts.cwd)
+      ? measureCompactionTrigger(opts.cwd, CLAUDE_PROJECTS_DIR, undefined, configuredTriggerTokens)
       : null;
 
   let effectiveTriggerTokens: number;

package/statusline-command.sh

@@ -699,8 +699,12 @@ if [ "$session_provider" = "anthropic" ]; then
         remaining_secs=$((seven_reset_epoch - now_epoch))
         [ "$remaining_secs" -lt 0 ] && remaining_secs=0
         elapsed_secs=$((window_secs - remaining_secs))
-        # Daily pace: actual spend/day vs dynamic budget
-        # Budget = remaining capacity / remaining days (not static 100/7)
+        # Daily pace: actual spend/day vs the flat weekly share.
+        # Budget = static 100/7 (not remaining capacity / remaining days): the
+        # user reads "1d" as "what I may spend today", a fixed share of the
+        # week, not a figure that shrinks as the week is used — dividing the
+        # shrinking remainder by the shrinking remaining days double-counted
+        # overspend and drove the pace red for no new reason.
         elapsed_days_x10=$((elapsed_secs * 10 / 86400))
         # A per-day rate divided by a fraction of a day is not a rate, it is an
         # extrapolation from noise: an hour into a fresh window the old clamp to
@@ -708,10 +712,7 @@ if [ "$session_provider" = "anthropic" ]; then
         # Below half a day there is nothing to pace against yet — say nothing.
         if [ "$elapsed_days_x10" -ge 5 ]; then
             spend_per_day=$((seven_day_int * 10 / elapsed_days_x10))
-            remaining_days_x10=$((remaining_secs * 10 / 86400))
-            [ "$remaining_days_x10" -lt 1 ] && remaining_days_x10=1
-            remaining_budget=$((100 - seven_day_int))
-            budget_per_day=$((remaining_budget * 10 / remaining_days_x10))
+            budget_per_day=$((100 / 7))
             # Color: green = under budget, orange = near budget, red = over budget
             overspend=$((spend_per_day - budget_per_day))
             if [ "$overspend" -le -3 ] 2>/dev/null; then
@@ -903,10 +904,21 @@ if [ "$session_provider" != "anthropic" ]; then
 fi
 
 # LINE 3 - Context meter + usage limits
-# Auto-compact remaining: how much context left until compaction triggers
+# Auto-compact remaining: how much context left until compaction triggers.
+# Claude Code fires the auto-compact hook at pct/100 * (window - 20000)
+# tokens, not at pct% of the raw window — the first 20k tokens of any window
+# are reserved and never count toward the trigger. Computing "% left" against
+# the raw window (as a plain threshold-context_pct subtraction did) reads as
+# "the window is full" on a 1M-token session that still has 80% of its real
+# capacity free. Work in tokens, then re-express as a percent of the real
+# window so the figure is comparable across window sizes.
 ac_threshold="${CLAUDE_AUTOCOMPACT_PCT_OVERRIDE:-80}"
-ac_remaining=$((ac_threshold - context_pct))
-[ "$ac_remaining" -lt 0 ] && ac_remaining=0
+ac_trigger_tokens=$((ac_threshold * (context_size - 20000) / 100))
+ac_used_tokens=$((context_pct * context_size / 100))
+ac_left_tokens=$((ac_trigger_tokens - ac_used_tokens))
+[ "$ac_left_tokens" -lt 0 ] && ac_left_tokens=0
+ac_remaining=$((ac_left_tokens * 100 / context_size))
+ac_left_k=$((ac_left_tokens / 1000))
 # Color the remaining %: red ≤5, yellow ≤15, green otherwise
 if [ "$ac_remaining" -le 5 ] 2>/dev/null; then
     ac_color="$BRIGHT_RED"
@@ -915,7 +927,7 @@ elif [ "$ac_remaining" -le 15 ] 2>/dev/null; then
 else
     ac_color="$BRIGHT_GREEN"
 fi
-ac_suffix=" ${ac_color}(${ac_remaining}%% left)${RESET}"
+ac_suffix=" ${ac_color}(${ac_remaining}%% left, ${ac_left_k}K)${RESET}"
 
 if [ "$context_pct" -gt 0 ] 2>/dev/null; then
     # Color based on usage: green < 50%, yellow 50-75%, red > 75%