@tekmidian/pai 0.39.0 → 0.40.0

package/docs/worker.md

@@ -265,6 +265,49 @@ A quota failure before the first tool call is re-run on the next provider and
 logged as `WORKER-REROUTE`. `pai worker providers enable <name>` clears a
 cooldown by hand.
 
+## When the Anthropic plan runs out
+
+`pai worker fallback on [provider]` switches the whole machine: every NEW
+Claude Code process — interactive sessions, task-bus sessions, the daemon's
+headless summarizer — runs on that worker provider instead of the Anthropic
+login, until `pai worker fallback off`. Use it when the plan budget is gone
+but work must continue.
+
+What `on` does:
+
+- Writes the provider into the `env` block of `~/.claude/settings.json`:
+  `ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`, the three
+  `ANTHROPIC_DEFAULT_*_MODEL` pins (fast model as haiku, default as sonnet
+  and opus), the provider's own env (`API_TIMEOUT_MS` …), plus
+  `ENABLE_TOOL_SEARCH=true` and
+  `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`.
+- Pins the top-level `model` key to the provider's default model.
+- Saves the replaced values under `workers.fallback.saved` in
+  `~/.config/pai/config.json` and writes a `FALLBACK-ACTIVE.md` note into the
+  workers log dir telling running sessions what to do.
+
+Notes:
+
+- **The token sits in settings.json.** `on` reads it from the provider's key
+  file at switch time; `off` removes it again. That is the price of switching
+  every process without touching each one's environment.
+- `off` restores settings.json exactly — only the keys `on` touched change.
+  Both files are written atomically; `CLAUDE_SETTINGS_PATH` points `on`/`off`
+  at a copy for dry runs.
+- **Running sessions are not switched.** A Claude Code process keeps the
+  provider it started with until restarted. `pai worker fallback status`
+  lists running sessions (AIBroker registry when populated, else `ps`) and
+  the note path; its one-line instruction for each of them: restart the
+  session in its project directory, keep the same AIBroker name.
+- The Agent hook is unchanged: subagents keep routing to `pai worker run`
+  workers, which set their own per-provider env.
+- `on` is idempotent (re-applying heals an interrupted switch), and switching
+  providers while on restores the first switch's savings before saving fresh.
+- MCP: `worker_fallback` (action `on`/`off`/`status`, optional `provider`);
+  chat phrases "switch everything to glm", "fallback on", "back to
+  anthropic", "fallback off", "is fallback on" are mapped in the Worker
+  skill.
+
 ## What a worker is
 
 - One `claude -p … --output-format stream-json --verbose` process per call,
@@ -340,8 +383,8 @@ behaviour — no prompt row, no ticker, stdin still the operator channel.
 Any worker may start its own workers: the runner exports `PAI_WORKER_ID` in
 every worker's environment, and a `pai worker run` launched from inside one
 records `parent` in its status — so the forest is visible in `ps` (children
-indented under their parent, `├`/`└` connectors), the status line (`↳` under
-the parent) and each child gets its own follow pane. Handoffs travel **up
+indented under their parent, `├`/`└` connectors) and each child gets its own
+follow pane. Handoffs travel **up
 only**, from a child to its parent:
 
 ```
@@ -352,8 +395,8 @@ pai worker handoff '{"kind":"proposal","text":"run this on a cheap provider","da
 `result` is sent automatically when a child finishes). The handoff is appended
 to `<logDir>/<parent>.inbox.jsonl` (durable, ordered) and, when the parent is
 running, also delivered as an operator message `[handoff from <child id>]`. The
-parent sees it in its pane (`◆ from <id> · kind: text`, magenta), `ps` and the
-status line show `◆N` for an inbox with N handoffs, and `replay`/`follow`
+parent sees it in its pane (`◆ from <id> · kind: text`, magenta), `ps` shows
+`◆N` for an inbox with N handoffs, and `replay`/`follow`
 merge them into the transcript by timestamp. There is no sideways channel:
 siblings never see each other, everything goes up.
 
@@ -425,9 +468,9 @@ drive the desktop until it is handed over.
 
 Status files carry `contextTokens` (input + cache read + cache creation +
 output of the last assistant turn) and `contextWindow` (from the init event,
-else the provider's `contextWindow`, else 200 000). The `ps` table and the
-status line show `ctx 84k/200k (42%)` once it passes 60 % — yellow past
-70 %, red past 85 % — and the pane's liveness line always shows it.
+else the provider's `contextWindow`, else 200 000). The `ps` table shows
+`ctx 84k/200k (42%)` once it passes 60 % — yellow past 70 %, red past
+85 % — and the pane's liveness line always shows it.
 
 ### MCP for workers
 
@@ -516,7 +559,25 @@ the CLI calls.
 
 ## Status line
 
-Line 4 of the statusline lists this session's running workers (provider,
-label, age, current tool, context meter past 60 %) plus today's ✓/✗ tally.
-It prefers the standalone `~/.claude/worker-status-line.mjs` (plain node,
-built by `bun run build`) and falls back to `pai worker status-line`.
+Line 4 of the statusline is the worker bar: the provider and running-worker
+count, one row per running spawned worker, and today's ✓/✗ tally. It prefers
+the standalone `~/.claude/worker-status-line.mjs` (plain node, built by
+`bun run build`) and falls back to `pai worker status-line`.
+
+Example: `glm ▶2 | fix black buttons · 6m · grep … | spotcheck login · 1m · Edit: button.ts   ✓75 ✗4 today`
+
+Segment by segment:
+
+- provider tag (`glm`) — the chat pane's provider; `workers` when there is no tracked chat pane and the running workers are mixed
+- `▶2` — this terminal's running spawned workers: `state=running` **and** a live pid **and** not the chat pane; nothing at zero, so an idle terminal shows just `glm`
+- row `name · age · step` — the worker's `--label` (else the first 70 chars of the prompt, `unlabeled` when the run had neither), time since it started, and the verb of what it is doing; `#id` (the short form `pai worker ps` shows) joins the name only when two running workers share a label
+- step (`grep …`) — the current tool trimmed to its verb: no `Bash:` prefix, no flags, no quotes, ≤24 chars; file tools keep their `Edit: button.ts` shape
+- `✓75 ✗4 today` — today's finished workers: done vs failed
+
+The chat pane itself contributes only its provider — its age, state and
+inbox live in `pai worker ps`, never in the bar. Rows are flat and
+oldest-first; the worker forest (`↳` depth) and `◆N` inbox marks are `ps`
+territory too. A status file from before the `origin` flag (a running entry
+with no origin, the unlabeled placeholder and zero turns) is treated as the
+chat pane so it does not render as a phantom worker — that shim goes away
+once every pane runs code that writes `origin`.

package/package.json

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

package/scripts/build-hooks.mjs

@@ -29,6 +29,7 @@ import {
 } from "fs";
 import { join, resolve, basename } from "path";
 import { homedir, platform } from "os";
+import { isInsideWorkerWorktree } from "./lib/sync-guard.mjs";
 
 const HOOKS_SRC = "src/hooks/ts";
 const HOOKS_OUT = "dist/hooks";
@@ -143,7 +144,11 @@ console.log(
 // --sync: Symlink (or copy on Windows) all deployable files to ~/.claude/
 // ---------------------------------------------------------------------------
 
-if (doSync) {
+if (doSync && isInsideWorkerWorktree(process.cwd())) {
+  // Never repoint the live ~/.claude symlinks at a worktree that `pai worker
+  // merge` will delete — see scripts/lib/sync-guard.mjs.
+  console.log("✔ Hook symlinks skipped: build runs inside a worker worktree");
+} else if (doSync) {
   const useSymlinks = platform() !== "win32";
   const claudeDir = join(homedir(), ".claude");
   const hooksTarget = join(claudeDir, "Hooks");

package/scripts/build-skill-stubs.mjs

@@ -32,6 +32,7 @@ import {
 } from "fs";
 import { join, resolve } from "path";
 import { homedir, platform } from "os";
+import { isInsideWorkerWorktree } from "./lib/sync-guard.mjs";
 
 const PROMPTS_DIR = "src/daemon-mcp/prompts";
 const CUSTOM_DIR = join(PROMPTS_DIR, "custom");
@@ -107,13 +108,21 @@ function syncSymlinks(generatedNames) {
     const source = resolve(join(STUBS_OUT, name));
     const target = join(skillsDir, name);
 
+    // lstat once: dangling links must count as symlinks (existsSync misses them)
+    let entry;
+    try {
+      entry = lstatSync(target);
+    } catch {
+      // absent — fresh install
+    }
+
     // Never overwrite non-symlink directories (user's own skills)
-    if (existsSync(target) && !lstatSync(target).isSymbolicLink()) {
+    if (entry && !entry.isSymbolicLink()) {
       continue;
     }
 
-    // Check existing symlink
-    if (existsSync(target) && lstatSync(target).isSymbolicLink()) {
+    // Check existing symlink (may be dangling)
+    if (entry) {
       if (resolve(readlinkSync(target)) === source) {
         current++;
         continue;
@@ -197,6 +206,10 @@ for (const [fileName, dir] of [
 const customLabel = customNames.length > 0 ? ` (${builtinNames.length} built-in + ${customNames.length} custom)` : "";
 console.log(`✔ ${generated} skill stubs generated in ${STUBS_OUT}/${customLabel}`);
 
-if (doSync) {
+if (doSync && isInsideWorkerWorktree(process.cwd())) {
+  // Never repoint the live ~/.claude/skills symlinks at a worktree that
+  // `pai worker merge` will delete — see scripts/lib/sync-guard.mjs.
+  console.log("✔ Skill symlinks skipped: build runs inside a worker worktree");
+} else if (doSync) {
   syncSymlinks(generatedDirNames);
 }

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(