@tekmidian/pai 0.39.1 → 0.40.0

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

@@ -14,6 +14,8 @@ import {
   resolveAutocompactPct,
   measureCompactionTrigger,
   modelFamily,
+  isForeignModelFamily,
+  nativeModelFamilies,
   selectedCompactionSamples,
   transcriptModelFamily,
   crossedThresholds,
@@ -21,6 +23,7 @@ import {
   DEFAULT_CONTEXT_WINDOW,
   type ContextFillReading,
 } from "./context-fill.js";
+import { contextWindowFromModelId } from "../../../utils/model-window.js";
 
 let root: string;
 
@@ -705,9 +708,12 @@ describe("measureCompactionTrigger — foreign-model transcripts are ignored", (
 });
 
 describe("modelFamily / transcriptModelFamily", () => {
-  it("classifies claude-, foreign, synthetic and missing models", () => {
+  it("keys families from the id itself, not from an Anthropic allowlist", () => {
     expect(modelFamily("claude-opus-5")).toBe("claude");
-    expect(modelFamily("other-model-1")).toBe("foreign");
+    expect(modelFamily("other-model-1")).toBe("other-model-1");
+    // the variant suffix is stripped, so one family has one key
+    expect(modelFamily("glm-5.3[1m]")).toBe("glm-5.3");
+    expect(modelFamily("glm-5.3")).toBe("glm-5.3");
     expect(modelFamily("<synthetic>")).toBe("unknown");
     expect(modelFamily(null)).toBe("unknown");
     expect(modelFamily("")).toBe("unknown");
@@ -722,11 +728,159 @@ describe("modelFamily / transcriptModelFamily", () => {
         [assistantLine("other-model-1"), compactBoundaryLine(1, "2026-09-17T09:00:00.000Z"), assistantLine("claude-x-1")].join("\n") + "\n"
       );
       expect(transcriptModelFamily(path)).toBe("claude");
-      writeFileSync(path, [assistantLine("claude-x-1"), assistantLine("other-model-1"), assistantLine("<synthetic>")].join("\n") + "\n");
-      expect(transcriptModelFamily(path)).toBe("foreign");
+      writeFileSync(path, [assistantLine("claude-x-1"), assistantLine("glm-5.3[1m]"), assistantLine("<synthetic>")].join("\n") + "\n");
+      expect(transcriptModelFamily(path)).toBe("glm-5.3");
       expect(transcriptModelFamily(join(dir, "missing.jsonl"))).toBe("unknown");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// Foreignness is a comparison, not a prefix: a family is foreign exactly when
+// it is neither Claude nor one the worker registry configures. Keying it on
+// the claude- prefix made a non-Anthropic PRIMARY model read as foreign and
+// lose its own compaction/handover history.
+// ---------------------------------------------------------------------------
+
+describe("isForeignModelFamily / nativeModelFamilies", () => {
+  it("claude and unknown are never foreign; anything else depends on the registry", () => {
+    expect(isForeignModelFamily("claude")).toBe(false);
+    expect(isForeignModelFamily("unknown")).toBe(false);
+    expect(isForeignModelFamily("glm-5.3", new Set())).toBe(true);
+    expect(isForeignModelFamily("glm-5.3", new Set(["glm-5.3"]))).toBe(false);
+  });
+
+  it("collects the families of every configured provider model", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pai-native-families-"));
+    const configPath = join(dir, "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        workers: {
+          enabled: true,
+          active: "glm",
+          providers: {
+            glm: {
+              baseUrl: "https://api.example.com/api/anthropic",
+              keyFile: null,
+              models: { default: "example-5.3[1m]", fast: "example-5.3-flash" },
+              env: {},
+            },
+          },
+        },
+      })
+    );
+    try {
+      const families = nativeModelFamilies(configPath);
+      expect(families.has("example-5.3")).toBe(true); // variant suffix stripped
+      expect(families.has("example-5.3-flash")).toBe(true);
+      expect(isForeignModelFamily("example-5.3", families)).toBe(false);
+      expect(isForeignModelFamily("other-model-1", families)).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("an unreadable registry means nothing is native (the historical rule)", () => {
+    expect(nativeModelFamilies("/nonexistent/pai-config.json").size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// A provider-model primary session keeps its compaction history: the samples
+// are glm, the registry configures glm, so nothing is discarded — before and
+// after a simulated compaction alike.
+// ---------------------------------------------------------------------------
+
+describe("measureCompactionTrigger — provider-model transcripts are native", () => {
+  it("keeps glm compaction history across a simulated compaction, still drops foreign models", () => {
+    const dir = mkdtempSync(join(tmpdir(), "pai-native-trigger-"));
+    const configPath = join(dir, "config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        workers: {
+          enabled: true,
+          active: "glm",
+          providers: {
+            glm: {
+              baseUrl: "https://api.example.com/api/anthropic",
+              keyFile: null,
+              models: { default: "glm-5.3[1m]", fast: "glm-5.3-flash" },
+              env: {},
+            },
+          },
+        },
+      })
+    );
+    const projectsDir = join(dir, "projects");
+    const cwd = "/fake/project/glm";
+    const projectDir = join(projectsDir, encodeForFixture(cwd));
+    mkdirSync(projectDir, { recursive: true });
+    writeFileSync(
+      join(projectDir, "live.jsonl"),
+      [
+        assistantLine("glm-5.3[1m]"),
+        compactBoundaryLine(990_000, "2026-09-16T09:00:00.000Z", "u1"), // before
+        assistantLine("glm-5.3[1m]"),
+        compactBoundaryLine(784_000, "2026-09-17T09:00:00.000Z", "u2"), // after
+      ].join("\n") + "\n"
+    );
+    // a foreign-model worker transcript must still not shape the trigger
+    writeFileSync(
+      join(projectDir, "worker.jsonl"),
+      [assistantLine("other-model-1"), compactBoundaryLine(151_000, "2026-09-17T09:30:00.000Z", "u3")].join("\n") + "\n"
+    );
+    try {
+      expect(selectedCompactionSamples(cwd, projectsDir, configPath).map((s) => s.preTokens))
+        .toEqual([784_000, 990_000]);
+      expect(measureCompactionTrigger(cwd, projectsDir, configPath)).toBe(784_000);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Window size from the model id — a session whose model declares its window
+// ("[1m]") is measured against that, not against the assumed 200k default.
+// ---------------------------------------------------------------------------
+
+describe("contextWindowFromModelId", () => {
+  it("reads the bracketed variant suffix, and only that", () => {
+    expect(contextWindowFromModelId("glm-5.3[1m]")).toBe(1_000_000);
+    expect(contextWindowFromModelId("glm-5.3")).toBeNull();
+    expect(contextWindowFromModelId("")).toBeNull();
+    expect(contextWindowFromModelId(null)).toBeNull();
+  });
+});
+
+describe("contextFillFromTranscript — window from the transcript's own model", () => {
+  const glmTurn = (tokens: number) => ({
+    type: "assistant",
+    message: { role: "assistant", model: "glm-5.3[1m]", usage: { input_tokens: tokens, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } },
+  });
+
+  it("derives a 1M window from a glm-5.3[1m] transcript when the caller has none", () => {
+    const p = join(root, "glm.jsonl");
+    writeJsonl(p, [glmTurn(500_000)]);
+    const reading = contextFillFromTranscript(p);
+    expect(reading.windowSize).toBe(1_000_000);
+    expect(reading.fraction).toBeCloseTo(0.5);
+  });
+
+  it("an explicit caller window still wins, and a bare id falls back to the default", () => {
+    const p = join(root, "glm.jsonl");
+    writeJsonl(p, [glmTurn(500_000)]);
+    expect(contextFillFromTranscript(p, 200_000).windowSize).toBe(200_000);
+
+    const bare = join(root, "bare.jsonl");
+    writeJsonl(bare, [{
+      type: "assistant",
+      message: { role: "assistant", model: "glm-5.3", usage: { input_tokens: 500, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } },
+    }]);
+    expect(contextFillFromTranscript(bare).windowSize).toBe(DEFAULT_CONTEXT_WINDOW);
+  });
+});

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

@@ -32,10 +32,14 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  contextWindowFromModelId,
+  stripModelVariant,
+} from "../../../utils/model-window.js";
+import { readWorkersSection } from "../../../workers/config.js";
 
-/** Fallback window size when nothing on hand reports one. Matches the
- *  default statusline-command.sh already falls back to. */
-export const DEFAULT_CONTEXT_WINDOW = 200_000;
+export { DEFAULT_CONTEXT_WINDOW };
 
 /** How many trailing lines of the transcript to scan for a usage entry.
  *  A single turn is rarely more than a handful of JSONL lines (assistant
@@ -147,44 +151,60 @@ function usageTotal(usage: UsageEntry): number {
  * `message.usage` entry, read from the end backwards so a trailing line with
  * no usage field (a plain text turn, a tool_result) doesn't hide one just
  * before it.
+ *
+ * The window size, when the caller has none, is derived from the transcript's
+ * own last assistant model id ("glm-5.3[1m]" → 1,000,000) before falling back
+ * to the assumed default — a session whose model declares its window should
+ * not be measured against a guess.
  */
 export function contextFillFromTranscript(
   transcriptPath: string,
-  windowSize = DEFAULT_CONTEXT_WINDOW
+  windowSize?: number
 ): ContextFillReading {
-  if (!transcriptPath || !existsSync(transcriptPath)) return unknownReading(windowSize);
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return unknownReading(windowSize ?? DEFAULT_CONTEXT_WINDOW);
+  }
 
   let raw: string;
   try {
     raw = readFileSync(transcriptPath, "utf-8");
   } catch {
-    return unknownReading(windowSize);
+    return unknownReading(windowSize ?? DEFAULT_CONTEXT_WINDOW);
   }
 
   const lines = raw.trim().split("\n").filter((l) => l.trim());
   const tail = lines.slice(-TRANSCRIPT_TAIL_LINES);
 
+  // one pass from the end: the first usage entry is the fill reading, and the
+  // last assistant model seen (before or at that point) declares the window
+  let lastModel: string | null = null;
   for (let i = tail.length - 1; i >= 0; i--) {
-    let entry: { message?: { usage?: UsageEntry } };
+    let entry: { type?: string; message?: { usage?: UsageEntry; model?: unknown } };
     try {
       entry = JSON.parse(tail[i]);
     } catch {
       continue;
     }
+    if (entry?.type === "assistant" && lastModel === null) {
+      const model = entry.message?.model;
+      if (typeof model === "string" && model !== "") lastModel = model;
+    }
     const usage = entry?.message?.usage;
     if (usage && typeof usage === "object") {
+      const window = windowSize ?? contextWindowFromModelId(lastModel) ?? DEFAULT_CONTEXT_WINDOW;
       const usedTokens = usageTotal(usage);
       return {
         status: "ok",
         usedTokens,
-        windowSize,
-        fraction: usedTokens / windowSize,
+        windowSize: window,
+        fraction: usedTokens / window,
         source: "transcript",
       };
     }
   }
 
-  return unknownReading(windowSize);
+  const window = windowSize ?? contextWindowFromModelId(lastModel) ?? DEFAULT_CONTEXT_WINDOW;
+  return unknownReading(window);
 }
 
 // ---------------------------------------------------------------------------
@@ -195,18 +215,18 @@ export function getContextFill(
   input: { sessionId?: string; transcriptPath?: string; windowSize?: number },
   now = Date.now()
 ): ContextFillReading {
-  const windowSize = input.windowSize ?? DEFAULT_CONTEXT_WINDOW;
-
   if (input.sessionId) {
     const fromStatusline = readStatuslineFill(input.sessionId, now);
     if (fromStatusline) return fromStatusline;
   }
 
   if (input.transcriptPath) {
-    return contextFillFromTranscript(input.transcriptPath, windowSize);
+    // windowSize passes through only when the caller knows it; otherwise the
+    // transcript's own model id is asked first (see contextFillFromTranscript)
+    return contextFillFromTranscript(input.transcriptPath, input.windowSize);
   }
 
-  return unknownReading(windowSize);
+  return unknownReading(input.windowSize ?? DEFAULT_CONTEXT_WINDOW);
 }
 
 // ---------------------------------------------------------------------------
@@ -369,23 +389,61 @@ function listProjectTranscripts(cwd: string, projectsDir: string): string[] {
 const SYNTHETIC_MODEL = "<synthetic>";
 
 /**
- * Which family of model wrote a transcript. "claude" is the platform's own;
- * "foreign" is any other provider routed through the same CLI (a different
- * context window, so its compactions say nothing about ours); "unknown" is
- * no usable model field at all.
+ * Which family of model wrote a transcript: a stable key derived from the id
+ * itself, never from an Anthropic allowlist. "claude" is the platform's own;
+ * any other id reduces to its base form before any bracketed variant suffix
+ * ("glm-5.3[1m]" → "glm-5.3"), so the same model family always produces the
+ * same key; "unknown" is no usable model field at all. Whether a family is
+ * foreign is decided by comparison (see isForeignModelFamily), not by the
+ * key — keying "foreign" here is what made non-Anthropic primary models lose
+ * their own compaction history.
  */
-export type TranscriptModelFamily = "claude" | "foreign" | "unknown";
+export type TranscriptModelFamily = "claude" | "unknown" | (string & {});
 
 export function modelFamily(model: string | null | undefined): TranscriptModelFamily {
   if (typeof model !== "string" || model === "" || model === SYNTHETIC_MODEL) return "unknown";
-  return model.startsWith("claude-") ? "claude" : "foreign";
+  const base = stripModelVariant(model);
+  return base.startsWith("claude-") ? "claude" : base;
+}
+
+/**
+ * Is a model id foreign to this machine's sessions? A model is native when it
+ * is a Claude model or one the worker registry configures (any provider's
+ * default or fast alias — the models this stack actually runs on). Anything
+ * else, with a readable model id, is foreign. Doubt (no id, unreadable
+ * registry) reads as native: the callers that skip work on "foreign" must not
+ * skip it on doubt.
+ */
+export function isForeignModelFamily(
+  family: TranscriptModelFamily,
+  nativeFamilies?: Set<string>
+): boolean {
+  if (family === "unknown" || family === "claude") return false;
+  return !(nativeFamilies ?? nativeModelFamilies()).has(family);
+}
+
+/** Families of every model id the worker registry configures. Never throws:
+ *  an unreadable or missing registry means "nothing configured", which leaves
+ *  every non-Claude family foreign — the historical behaviour. */
+export function nativeModelFamilies(configPath?: string): Set<string> {
+  const families = new Set<string>();
+  try {
+    for (const p of Object.values(readWorkersSection(configPath).workers.providers)) {
+      families.add(modelFamily(p.models.default));
+      if (p.models.fast) families.add(modelFamily(p.models.fast));
+    }
+  } catch {
+    return families;
+  }
+  return families;
 }
 
 /**
  * The family of the LAST assistant model in a transcript — scanned from the
  * end so a long transcript costs one read and a few lines of parsing.
- * Unreadable or model-less transcripts are "unknown", never "foreign":
- * the callers that skip work on "foreign" must not skip it on doubt.
+ * Unreadable or model-less transcripts are "unknown", never foreign:
+ * the callers that skip work on foreign models must not skip it on doubt.
+ * Pair with isForeignModelFamily to judge the key.
  */
 export function transcriptModelFamily(path: string): TranscriptModelFamily {
   let raw: string;
@@ -417,7 +475,11 @@ export function transcriptModelFamily(path: string): TranscriptModelFamily {
  * the event's uuid (falling back to a timestamp+preTokens key for the rare
  * line with no uuid) so an event mirrored into `sessions/` is counted once.
  */
-function readCompactBoundarySamples(cwd: string, projectsDir: string): CompactBoundarySample[] {
+function readCompactBoundarySamples(
+  cwd: string,
+  projectsDir: string,
+  nativeFamilies: Set<string>
+): CompactBoundarySample[] {
   const byKey = new Map<string, CompactBoundarySample>();
 
   for (const path of listProjectTranscripts(cwd, projectsDir)) {
@@ -430,12 +492,14 @@ function readCompactBoundarySamples(cwd: string, projectsDir: string): CompactBo
 
     // The model governing each sample: the most recent assistant
     // `message.model` seen in this file before the compact_boundary. A
-    // transcript written by a non-Claude model (a headless worker on another
-    // provider, with a different context window) compacts at a different
-    // size and must not shape THIS project's trigger — two such workers
-    // compacting at ~151k pulled a real project's trigger from ~784k to
-    // ~151k. Samples with no model seen yet are kept: older transcripts
-    // may lack the field.
+    // transcript written by a model foreign to this machine (a headless
+    // worker on another provider, with a different context window) compacts
+    // at a different size and must not shape THIS project's trigger — two
+    // such workers compacting at ~151k pulled a real project's trigger from
+    // ~784k to ~151k. Native is Claude plus every model the registry
+    // configures, so a non-Anthropic PRIMARY model keeps its own history.
+    // Samples with no model seen yet are kept: older transcripts may lack
+    // the field.
     let lastModel: string | null = null;
     let foreignDiscards = 0;
 
@@ -464,7 +528,7 @@ function readCompactBoundarySamples(cwd: string, projectsDir: string): CompactBo
       if (typeof preTokens !== "number" || !Number.isFinite(preTokens)) continue;
       const timestampMs = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
       if (!Number.isFinite(timestampMs)) continue;
-      if (modelFamily(lastModel) === "foreign") {
+      if (isForeignModelFamily(modelFamily(lastModel), nativeFamilies)) {
         foreignDiscards++;
         continue;
       }
@@ -478,7 +542,7 @@ function readCompactBoundarySamples(cwd: string, projectsDir: string): CompactBo
     if (foreignDiscards > 0) {
       console.error(
         `[context-fill] ignored ${foreignDiscards} compaction sample(s) from a ` +
-        `non-Claude transcript (model=${lastModel}): ${path}`
+        `foreign-model transcript (model=${lastModel}): ${path}`
       );
     }
   }
@@ -495,10 +559,12 @@ function readCompactBoundarySamples(cwd: string, projectsDir: string): CompactBo
  */
 export function selectedCompactionSamples(
   cwd: string,
-  projectsDir: string = CLAUDE_PROJECTS_DIR
+  projectsDir: string = CLAUDE_PROJECTS_DIR,
+  configPath?: string
 ): CompactBoundarySample[] {
   if (!cwd) return [];
-  return readCompactBoundarySamples(cwd, projectsDir).slice(0, MEASURED_TRIGGER_SAMPLE_SIZE);
+  return readCompactBoundarySamples(cwd, projectsDir, nativeModelFamilies(configPath))
+    .slice(0, MEASURED_TRIGGER_SAMPLE_SIZE);
 }
 
 /**
@@ -514,9 +580,10 @@ export function selectedCompactionSamples(
  */
 export function measureCompactionTrigger(
   cwd: string,
-  projectsDir: string = CLAUDE_PROJECTS_DIR
+  projectsDir: string = CLAUDE_PROJECTS_DIR,
+  configPath?: string
 ): number | null {
-  const samples = selectedCompactionSamples(cwd, projectsDir);
+  const samples = selectedCompactionSamples(cwd, projectsDir, configPath);
   if (samples.length === 0) return null;
   const trigger = Math.min(...samples.map((s) => s.preTokens));
   console.error(

package/statusline-command.sh

@@ -35,8 +35,18 @@ DA_COLOR="${DA_COLOR:-purple}"  # Color for the assistant name
 # Extract data from JSON input
 current_dir=$(echo "$input" | jq -r '.workspace.current_dir')
 model_name=$(echo "$input" | jq -r '.model.display_name')
+model_id=$(echo "$input" | jq -r '.model.id // .model.display_name // empty')
 cc_version=$(echo "$input" | jq -r '.version // "unknown"')
 
+# Provider detection: strip any [...] suffix (e.g. the [1m] context marker)
+# so "glm-5.3[1m]" is recognized as a glm model. glm sessions read their plan
+# usage from Z.ai, everything else keeps the Anthropic OAuth path.
+model_base="${model_id%%\[*}"
+is_glm=0
+case "$model_base" in
+    [Gg][Ll][Mm]*) is_glm=1 ;;
+esac
+
 # Get directory name
 dir_name=$(basename "$current_dir")
 
@@ -112,7 +122,14 @@ fi
 
 # Extract context window usage from Claude Code's JSON input (no JSONL parsing needed)
 context_pct=$(echo "$input" | jq -r '.context_window.used_percentage // 0' 2>/dev/null)
-context_size=$(echo "$input" | jq -r '.context_window.context_window_size // 200000' 2>/dev/null)
+# When the payload omits the window size, derive it from the model id instead
+# of assuming 200k for every model: [1m] models carry a 1M window, everything
+# else keeps the claude default. This value is persisted below for hooks.
+default_context_size=200000
+case "$model_id" in
+    *"[1m]") default_context_size=1000000 ;;
+esac
+context_size=$(echo "$input" | jq -r --argjson d "$default_context_size" '.context_window.context_window_size // $d' 2>/dev/null)
 context_used_k=$(( (context_pct * context_size / 100) / 1000 ))
 context_max_k=$((context_size / 1000))
 
@@ -125,7 +142,7 @@ if [ -n "$statusline_session_id" ]; then
     context_state_file="${TMPDIR:-/tmp}/pai-context-${statusline_session_id}.json"
     jq -n \
         --argjson used_percentage "${context_pct:-0}" \
-        --argjson context_window_size "${context_size:-200000}" \
+        --argjson context_window_size "${context_size:-$default_context_size}" \
         --arg session_id "$statusline_session_id" \
         --argjson timestamp "$(date +%s000)" \
         '{used_percentage: $used_percentage, context_window_size: $context_window_size, session_id: $session_id, timestamp: $timestamp}' \
@@ -347,11 +364,22 @@ if [ -n "$mcp_line2" ]; then
 fi
 
 
-# Fetch OAuth usage (5-hour current + 7-day weekly) with caching
+# Usage suffix: provider-aware. glm sessions read the Z.ai plan quota
+# (5-hour + weekly credit windows), everything else keeps the Anthropic
+# OAuth path (5-hour + 1d pace + 7-day). Both cache for usage_cache_ttl.
 usage_cache="/tmp/claude/statusline-usage-cache.json"
+zai_cache="/tmp/claude/statusline-zai-cache.json"
 usage_cache_ttl=60  # seconds
 usage_suffix=""
 
+# Color based on utilization: green < 50%, yellow 50-75%, red > 75%
+_usage_color() {
+    local pct=$1
+    if [ "$pct" -gt 75 ] 2>/dev/null; then echo "$BRIGHT_RED"
+    elif [ "$pct" -gt 50 ] 2>/dev/null; then echo "$BRIGHT_YELLOW"
+    else echo "$BRIGHT_GREEN"; fi
+}
+
 _fetch_usage() {
     # Try to get OAuth token from macOS Keychain
     local token=""
@@ -367,18 +395,21 @@ _fetch_usage() {
     [ -n "$response" ] && echo "$response" > "$usage_cache"
 }
 
-# Use cache if fresh, otherwise fetch in background
-if [ -f "$usage_cache" ]; then
-    cache_age=$(( $(date +%s) - $(stat -f %m "$usage_cache" 2>/dev/null || echo 0) ))
-    if [ "$cache_age" -gt "$usage_cache_ttl" ]; then
+# Use cache if fresh, otherwise fetch in background (Anthropic plan only)
+if [ "$is_glm" -eq 0 ]; then
+    if [ -f "$usage_cache" ]; then
+        cache_age=$(( $(date +%s) - $(stat -f %m "$usage_cache" 2>/dev/null || echo 0) ))
+        if [ "$cache_age" -gt "$usage_cache_ttl" ]; then
+            _fetch_usage &
+        fi
+    else
         _fetch_usage &
     fi
-else
-    _fetch_usage &
 fi
 
-# Read cached usage data
-if [ -f "$usage_cache" ]; then
+# Read cached usage data — skipped on glm sessions so Anthropic-plan numbers
+# (usage line AND the advisor-mode budget file) never leak into a glm statusline
+if [ "$is_glm" -eq 0 ] && [ -f "$usage_cache" ]; then
     five_hour=$(jq -r '.five_hour.utilization // 0' "$usage_cache" 2>/dev/null)
     seven_day=$(jq -r '.seven_day.utilization // 0' "$usage_cache" 2>/dev/null)
     five_reset=$(jq -r '.five_hour.resets_at // empty' "$usage_cache" 2>/dev/null)
@@ -406,14 +437,6 @@ if [ -f "$usage_cache" ]; then
         seven_reset_fmt=$([ "$seven_reset_epoch" -gt 0 ] 2>/dev/null && date -r "$seven_reset_epoch" "+%a %H:%M" 2>/dev/null || echo "")
     fi
 
-    # Color based on utilization: green < 50%, yellow 50-75%, red > 75%
-    _usage_color() {
-        local pct=$1
-        if [ "$pct" -gt 75 ] 2>/dev/null; then echo "$BRIGHT_RED"
-        elif [ "$pct" -gt 50 ] 2>/dev/null; then echo "$BRIGHT_YELLOW"
-        else echo "$BRIGHT_GREEN"; fi
-    }
-
     five_color=$(_usage_color "$five_hour_int")
     seven_color=$(_usage_color "$seven_day_int")
 
@@ -504,6 +527,80 @@ if [ -f "$usage_cache" ]; then
     usage_suffix="${usage_suffix} ${SEPARATOR_COLOR}│${RESET} ${seven_color}${seven_label}${RESET}"
 fi
 
+# Z.ai plan quota (glm sessions). The monitor endpoint exposes two credit
+# windows: limits[] number==5 is the 5-hour window, number==1 the weekly one
+# (nextResetTime in epoch ms) — no 1d window exists on this plan, so none is
+# rendered. PAI_ZAI_QUOTA_URL overrides the endpoint (kill switch / testing).
+_fetch_zai_usage() {
+    local key="${ZAI_API_KEY:-}"
+    if [ -z "$key" ] && [ -f "$HOME/.config/zai/api_key" ]; then
+        key=$(tr -d '[:space:]' < "$HOME/.config/zai/api_key")
+    fi
+    [ -n "$key" ] || return
+    mkdir -p /tmp/claude
+    local response
+    response=$(curl -sf --max-time 3 \
+        -H "Authorization: Bearer $key" \
+        -H "Accept: application/json" \
+        "${PAI_ZAI_QUOTA_URL:-https://api.z.ai/api/monitor/usage/quota/limit}" 2>/dev/null)
+    # A bad key returns HTTP 200 with empty limits — only cache responses
+    # that actually carry quota windows, so a broken fetch is never cached.
+    if [ -n "$response" ] && echo "$response" | jq -e '.data.limits | length > 0' >/dev/null 2>&1; then
+        echo "$response" > "$zai_cache"
+    fi
+}
+
+if [ "$is_glm" -eq 1 ]; then
+    # Use cache if fresh, otherwise fetch in background
+    if [ -f "$zai_cache" ]; then
+        cache_age=$(( $(date +%s) - $(stat -f %m "$zai_cache" 2>/dev/null || echo 0) ))
+        if [ "$cache_age" -gt "$usage_cache_ttl" ]; then
+            _fetch_zai_usage &
+        fi
+    else
+        _fetch_zai_usage &
+    fi
+
+    zai_five_pct=""
+    zai_seven_pct=""
+    zai_five_reset_ms=""
+    zai_seven_reset_ms=""
+    if [ -f "$zai_cache" ]; then
+        zai_five_pct=$(jq -r '.data.limits[]? | select(.number == 5) | .percentage' "$zai_cache" 2>/dev/null | head -1)
+        zai_seven_pct=$(jq -r '.data.limits[]? | select(.number == 1) | .percentage' "$zai_cache" 2>/dev/null | head -1)
+        zai_five_reset_ms=$(jq -r '.data.limits[]? | select(.number == 5) | .nextResetTime' "$zai_cache" 2>/dev/null | head -1)
+        zai_seven_reset_ms=$(jq -r '.data.limits[]? | select(.number == 1) | .nextResetTime' "$zai_cache" 2>/dev/null | head -1)
+    fi
+
+    if [ -n "$zai_five_pct" ] && [ "$zai_five_pct" != "null" ]; then
+        zai_five_int=$(printf "%.0f" "$zai_five_pct" 2>/dev/null || echo "?")
+        zai_five_reset_fmt=""
+        if [ -n "$zai_five_reset_ms" ] && [ "$zai_five_reset_ms" != "null" ]; then
+            # nextResetTime is epoch milliseconds; date -r wants seconds
+            zai_five_epoch=$(( zai_five_reset_ms / 1000 ))
+            [ "$zai_five_epoch" -gt 0 ] 2>/dev/null && zai_five_reset_fmt=$(date -r "$zai_five_epoch" "+%H:%M" 2>/dev/null || echo "")
+        fi
+        zai_five_label="zai 5h: ${zai_five_int}%%"
+        [ -n "$zai_five_reset_fmt" ] && zai_five_label="${zai_five_label} → ${zai_five_reset_fmt}"
+        usage_suffix=" ${SEPARATOR_COLOR}│${RESET} $(_usage_color "$zai_five_int")${zai_five_label}${RESET}"
+        if [ -n "$zai_seven_pct" ] && [ "$zai_seven_pct" != "null" ]; then
+            zai_seven_int=$(printf "%.0f" "$zai_seven_pct" 2>/dev/null || echo "?")
+            zai_seven_reset_fmt=""
+            if [ -n "$zai_seven_reset_ms" ] && [ "$zai_seven_reset_ms" != "null" ]; then
+                zai_seven_epoch=$(( zai_seven_reset_ms / 1000 ))
+                [ "$zai_seven_epoch" -gt 0 ] 2>/dev/null && zai_seven_reset_fmt=$(date -r "$zai_seven_epoch" "+%a %H:%M" 2>/dev/null || echo "")
+            fi
+            zai_seven_label="7d: ${zai_seven_int}%%"
+            [ -n "$zai_seven_reset_fmt" ] && zai_seven_label="${zai_seven_label} → ${zai_seven_reset_fmt}"
+            usage_suffix="${usage_suffix} ${SEPARATOR_COLOR}│${RESET} $(_usage_color "$zai_seven_int")${zai_seven_label}${RESET}"
+        fi
+    else
+        # No key, timeout, non-200 or empty limits — show the marker instead
+        # of silently falling back to Anthropic-plan numbers.
+        usage_suffix=" ${SEPARATOR_COLOR}│${RESET} ${LINE3_ACCENT}zai 5h: ?${RESET}"
+    fi
+fi
+
 # LINE 3 - Context meter + usage limits
 # Auto-compact remaining: how much context left until compaction triggers
 ac_threshold="${CLAUDE_AUTOCOMPACT_PCT_OVERRIDE:-80}"
@@ -517,7 +614,7 @@ elif [ "$ac_remaining" -le 15 ] 2>/dev/null; then
 else
     ac_color="$BRIGHT_GREEN"
 fi
-ac_suffix=" ${ac_color}(${ac_remaining}%%)${RESET}"
+ac_suffix=" ${ac_color}(${ac_remaining}%% left)${RESET}"
 
 if [ "$context_pct" -gt 0 ] 2>/dev/null; then
     # Color based on usage: green < 50%, yellow 50-75%, red > 75%
@@ -545,7 +642,9 @@ elif command -v pai >/dev/null 2>&1; then
     worker_status_cmd="pai worker status-line"
 fi
 if [ -n "$worker_status_cmd" ]; then
-    worker_line="$("$worker_status_cmd" "${ITERM_SESSION_ID:-}" "${PWD:-}" 2>/dev/null)"
+    # third arg: this session's claude id — lets the worker line claim workers
+    # spawned from this session's Bash tool, which carry no terminal identity
+    worker_line="$("$worker_status_cmd" "${ITERM_SESSION_ID:-}" "${PWD:-}" "${statusline_session_id:-}" 2>/dev/null)"
     if [ -n "$worker_line" ]; then
         printf "${LINE3_PRIMARY}🐝 ${RESET}${LINE3_ACCENT}%s${RESET}\n" "$worker_line"
     fi