@huseynsnmz/pi-suite 0.2.2 → 0.2.3

package/packages/router/src/config.ts

@@ -1,40 +1,53 @@
-// ~/.pi/agent/router.json. Global only: a repository must not choose where your code gets sent.
-import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+// The router section of ~/.pi/agent/suite.json. Global only: a repository must not choose where your code gets sent.
+import { readSection, writeSection } from "../../../src/settings.ts";
 
 /** The judge's model lives only in the judge's own config, so there's one answer to which model judges. */
 export const ROLES = ["plan", "build", "reader", "subagent", "fallback"] as const;
 export type Role = (typeof ROLES)[number];
 
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+/** A role left out uses the level selected with /effort. */
+export type RoleThinking = Partial<Record<Role, ThinkingLevel>>;
+
 export interface RouterConfig {
   plan: string;
   build: string;
   reader?: string;
   subagent?: string;
   fallback?: string;
+  thinking?: RoleThinking;
 }
 
-export type SavedConfig = Partial<Record<Role, string>>;
+export type SavedConfig = Partial<Record<Role, string>> & { thinking?: RoleThinking };
 
 export const VIRTUAL_PROVIDER = "router";
 export const VIRTUAL_ID = "auto";
 
-export function configPath(agentDir: string): string {
-  return join(agentDir, "router.json");
-}
-
 export function parseRef(ref: string): { provider: string; id: string } {
   const at = ref.indexOf("/");
   return { provider: ref.slice(0, at), id: ref.slice(at + 1) };
 }
 
+function parseThinking(raw: unknown): void {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("suite.json router: thinking must be an object");
+  for (const [role, level] of Object.entries(raw)) {
+    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`suite.json router: thinking has an unknown role "${role}". Use ${ROLES.join(", ")}`);
+    if (!(THINKING_LEVELS as readonly unknown[]).includes(level)) throw new Error(`suite.json router: thinking.${role} must be one of ${THINKING_LEVELS.join(", ")}`);
+  }
+}
+
 /** Throws on anything it doesn't understand, so a typo can't quietly send work to the wrong model. */
 export function parseConfig(raw: unknown): SavedConfig {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("router.json must be an object");
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new Error("suite.json router must be an object");
   for (const [role, ref] of Object.entries(raw)) {
-    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`router.json: unknown role "${role}". Use ${ROLES.join(", ")}`);
-    if (typeof ref !== "string" || !/^[^/\s]+\/\S+$/.test(ref)) throw new Error(`router.json: ${role} must look like "provider/model"`);
-    if (ref.startsWith(`${VIRTUAL_PROVIDER}/`)) throw new Error(`router.json: ${role} can't be a virtual model`);
+    if (role === "thinking") {
+      parseThinking(ref);
+      continue;
+    }
+    if (!(ROLES as readonly string[]).includes(role)) throw new Error(`suite.json router: unknown role "${role}". Use ${ROLES.join(", ")}`);
+    if (typeof ref !== "string" || !/^[^/\s]+\/\S+$/.test(ref)) throw new Error(`suite.json router: ${role} must look like "provider/model"`);
+    if (ref.startsWith(`${VIRTUAL_PROVIDER}/`)) throw new Error(`suite.json router: ${role} can't be a virtual model`);
   }
   return raw as SavedConfig;
 }
@@ -43,23 +56,11 @@ export function isComplete(saved: SavedConfig): saved is RouterConfig {
   return saved.plan !== undefined && saved.build !== undefined;
 }
 
-/** An absent file is a router nobody has set up yet. A broken one throws. */
+/** Nothing there is a router nobody has set up yet. Something broken throws. */
 export function loadConfig(agentDir: string): SavedConfig {
-  let text: string;
-  try {
-    text = readFileSync(configPath(agentDir), "utf8");
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
-    throw error;
-  }
-  return parseConfig(JSON.parse(text));
+  return parseConfig(readSection(agentDir, "router"));
 }
 
 export function saveConfig(agentDir: string, saved: SavedConfig): void {
-  // A linked file, as in a dotfiles setup, stays linked.
-  const named = configPath(agentDir);
-  const path = existsSync(named) ? realpathSync(named) : named;
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify(saved, null, 2)}\n`);
-  renameSync(temp, path);
+  writeSection(agentDir, "router", saved);
 }

package/packages/router/src/index.ts

@@ -1,15 +1,17 @@
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
 
-import { isComplete, loadConfig, parseConfig, parseRef, type Role, ROLES, type SavedConfig, saveConfig, VIRTUAL_ID, VIRTUAL_PROVIDER } from "./config.ts";
+import { isComplete, loadConfig, parseConfig, parseRef, type Role, ROLES, type SavedConfig, saveConfig, THINKING_LEVELS, type ThinkingLevel, VIRTUAL_ID, VIRTUAL_PROVIDER } from "./config.ts";
 import { judgeModel, setJudgeModel } from "./judge.ts";
 import { chooseModel, type RouterState } from "./route.ts";
 
 /** Other extensions emit these with an object, and whoever knows fills it in, whatever the load order. */
 const READER_PROBE = "pi-router:reader-model";
 const MODE_PROBE = "pi-modes:mode";
+const SETTINGS_PROBE = "pi-suite:router-settings";
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 const VIRTUAL_API = "pi-virtual";
+const SELECTED_LEVEL = "same as /effort";
 
 const JUDGE = "judge";
 const JUDGE_HELP = "decides permission asks for pi-permission-classifier";
@@ -46,7 +48,9 @@ export default function piRouter(pi: ExtensionAPI): void {
 
   pi.events.on(READER_PROBE, (data) => {
     if (!isComplete(saved)) return;
-    (data as { model?: string }).model = saved.reader ?? saved.build;
+    const probe = data as { model?: string; thinking?: ThinkingLevel };
+    probe.model = saved.reader ?? saved.build;
+    probe.thinking = saved.thinking?.[saved.reader === undefined ? "build" : "reader"];
   });
 
   function currentMode(): string | undefined {
@@ -56,8 +60,8 @@ export default function piRouter(pi: ExtensionAPI): void {
   }
 
   function register(): void {
-    // A broken file still registers, so router/auto stops with the reason rather than Pi picking another model.
-    if (registered || (!isComplete(saved) && problem === undefined)) return;
+    // Always listed. With nothing set or a broken file it stops with the reason, rather than Pi picking another model.
+    if (registered) return;
     registered = true;
     pi.registerVirtualModel<RouterState>({
       provider: VIRTUAL_PROVIDER,
@@ -73,14 +77,14 @@ export default function piRouter(pi: ExtensionAPI): void {
           subagent: process.env.PI_SUBAGENT_CHILD === "1",
           state: request.state,
           previous: refOf(request.previous?.model),
-          failed: request.failed && { model: refOf(request.failed.model) as string, errorMessage: request.failed.message.errorMessage },
+          failed: request.failed && { model: refOf(request.failed.model) as string, errorMessage: request.failed.message.errorMessage, thinking: request.failed.thinkingLevel },
           messages: request.messages,
         });
         const { provider, id } = parseRef(choice.model);
         const model = ctx.modelRegistry.find(provider, id);
         if (model === undefined) throw new Error(`pi-router: ${choice.model} isn't a known model. Run /router`);
         if (!ctx.modelRegistry.hasConfiguredAuth(model)) throw new Error(`pi-router: no login for ${choice.model}. Run /login or /router`);
-        return { model, thinkingLevel: request.thinkingLevel, state: choice.state };
+        return { model, thinkingLevel: choice.thinking ?? request.thinkingLevel, state: choice.state };
       },
     });
   }
@@ -94,9 +98,15 @@ export default function piRouter(pi: ExtensionAPI): void {
     ctx.ui.notify("The permission judge has no model of its own, so with router/auto it can't judge and every ask comes to you. Set judge in /router.", "warning");
   }
 
+  function warnIfNotSetUp(ctx: ExtensionContext): void {
+    if (problem !== undefined || isComplete(saved) || !ctx.hasUI || refOf(ctx.model) !== `${VIRTUAL_PROVIDER}/${VIRTUAL_ID}`) return;
+    ctx.ui.notify("router/auto has no models yet. Run /router to choose plan and build.", "warning");
+  }
+
   pi.on("session_start", (_event, ctx) => {
     register();
     if (problem !== undefined && ctx.hasUI) ctx.ui.notify(problem, "error");
+    warnIfNotSetUp(ctx);
     warnAboutJudge(ctx);
   });
   // Pi keeps virtual models across a reload, so one left here would outlive this extension being turned off.
@@ -105,18 +115,45 @@ export default function piRouter(pi: ExtensionAPI): void {
     registered = false;
     pi.unregisterVirtualModel(VIRTUAL_PROVIDER, VIRTUAL_ID);
   });
-  pi.on("model_select", (_event, ctx) => warnAboutJudge(ctx));
+  pi.on("model_select", (_event, ctx) => {
+    warnIfNotSetUp(ctx);
+    warnAboutJudge(ctx);
+  });
 
   function setRole(role: Role, ref: string | undefined): void {
     // Another session may have changed it since this one read it.
     const next: SavedConfig = { ...loadConfig(agentDir) };
     if (ref === undefined) delete next[role];
     else next[role] = ref;
+    // Another model may not have the same levels, so this role's level is chosen again.
+    if (next.thinking !== undefined) {
+      const { [role]: _dropped, ...others } = next.thinking;
+      if (Object.keys(others).length > 0) next.thinking = others;
+      else delete next.thinking;
+    }
     saved = parseConfig(next);
     saveConfig(agentDir, saved);
     register();
   }
 
+  function setThinking(role: Role, level: ThinkingLevel): void {
+    const next: SavedConfig = { ...loadConfig(agentDir) };
+    next.thinking = { ...next.thinking, [role]: level };
+    saved = parseConfig(next);
+    saveConfig(agentDir, saved);
+  }
+
+  /** Offers only what the chosen model can do. A model with no levels to choose has nothing to ask. */
+  async function chooseThinking(ctx: ExtensionContext, role: Role, ref: string): Promise<void> {
+    const { provider, id } = parseRef(ref);
+    const model = ctx.modelRegistry.find(provider, id);
+    const levels = model === undefined ? [] : getSupportedThinkingLevels(model);
+    if (levels.length < 2) return;
+    const picked = await ctx.ui.select(`Reasoning for ${role} on ${ref}`, [SELECTED_LEVEL, ...levels]);
+    if (picked === undefined || picked === SELECTED_LEVEL) return;
+    setThinking(role, picked as ThinkingLevel);
+  }
+
   async function chooseJudge(ctx: ExtensionContext, models: readonly string[]): Promise<void> {
     const picked = await ctx.ui.select(`${JUDGE} ${JUDGE_HELP}`, ["not set", ...models]);
     if (picked === undefined) return;
@@ -131,7 +168,7 @@ export default function piRouter(pi: ExtensionAPI): void {
   async function chooseRoles(ctx: ExtensionContext): Promise<void> {
     if (problem !== undefined) {
       // Saving over it would throw away whatever the file held.
-      ctx.ui.notify(`${problem}. Fix or delete ~/.pi/agent/router.json, then /reload.`, "error");
+      ctx.ui.notify(`${problem}. Fix the router section of ~/.pi/agent/suite.json, then /reload.`, "error");
       return;
     }
     const models = ctx.modelRegistry.getAvailable().filter((model) => model.api !== VIRTUAL_API).map((model) => `${model.provider}/${model.id}`);
@@ -141,7 +178,11 @@ export default function piRouter(pi: ExtensionAPI): void {
     }
     for (;;) {
       const judge = judgeModel(agentDir);
-      const rows = [...ROLES.map((role) => `${role}: ${saved[role] ?? UNSET[role] ?? "not set"}`), `${JUDGE}: ${judge ?? (judge === null ? "not set" : "not installed")}`];
+      const shown = (role: Role): string => {
+        const level = saved.thinking?.[role];
+        return `${saved[role] ?? UNSET[role] ?? "not set"}${saved[role] !== undefined && level !== undefined ? ` · ${level}` : ""}`;
+      };
+      const rows = [...ROLES.map((role) => `${role}: ${shown(role)}`), `${JUDGE}: ${judge ?? (judge === null ? "not set" : "not installed")}`];
       const row = await ctx.ui.select("Router: which role? (Esc when done)", rows);
       if (row === undefined) break;
       const role = ROLES[rows.indexOf(row)];
@@ -153,15 +194,22 @@ export default function piRouter(pi: ExtensionAPI): void {
       const picked = await ctx.ui.select(`${role} ${ROLE_HELP[role]}`, [...(unset === undefined ? [] : [unset]), ...models]);
       if (picked === undefined) continue;
       try {
-        setRole(role, picked === unset ? undefined : picked);
+        const ref = picked === unset ? undefined : picked;
+        setRole(role, ref);
+        if (ref !== undefined) await chooseThinking(ctx, role, ref);
       } catch (error) {
         ctx.ui.notify((error as Error).message, "error");
       }
     }
-    if (isComplete(saved)) ctx.ui.notify(`Choose ${VIRTUAL_PROVIDER}/${VIRTUAL_ID} in /model to use these.`, "info");
-    else ctx.ui.notify("The router needs both plan and build before router/auto appears.", "warning");
+    if (!isComplete(saved)) ctx.ui.notify("router/auto needs both plan and build before it can answer.", "warning");
+    else if (refOf(ctx.model) !== `${VIRTUAL_PROVIDER}/${VIRTUAL_ID}`) ctx.ui.notify(`Choose ${VIRTUAL_PROVIDER}/${VIRTUAL_ID} in /model to use these.`, "info");
   }
 
+  // /suite opens this screen too, without knowing how it works.
+  pi.events.on(SETTINGS_PROBE, (data) => {
+    (data as { open?: (ctx: ExtensionContext) => Promise<void> }).open = chooseRoles;
+  });
+
   pi.registerCommand("router", {
     description: "Choose which model does what for router/auto",
     handler: async (_args, ctx) => {

package/packages/router/src/route.ts

@@ -1,5 +1,5 @@
 // Which real model answers a request. Pure, so every rule can be tested without Pi.
-import type { RouterConfig } from "./config.ts";
+import type { Role, RouterConfig, ThinkingLevel } from "./config.ts";
 
 export interface RouterState {
   phase: "plan" | "build";
@@ -15,12 +15,14 @@ export interface RouteInput {
   subagent: boolean;
   state: RouterState | undefined;
   previous: string | undefined;
-  failed: { model: string; errorMessage: string | undefined } | undefined;
+  failed: { model: string; errorMessage: string | undefined; thinking?: ThinkingLevel } | undefined;
   messages: readonly { role: string; toolName?: string; isError?: boolean }[];
 }
 
 export interface RouteChoice {
   model: string;
+  /** Only when the role has its own. Otherwise the level selected with /effort applies. */
+  thinking?: ThinkingLevel;
   /** Only when it changed, because Pi stores every new object it gets. */
   state?: RouterState;
 }
@@ -42,9 +44,13 @@ function nextState(input: RouteInput): RouterState {
 }
 
 export function chooseModel(config: RouterConfig, input: RouteInput): RouteChoice {
-  const home = input.subagent ? (config.subagent ?? config.build) : config.build;
+  const forRole = (role: Role, model: string): Pick<RouteChoice, "model" | "thinking"> => {
+    const thinking = config.thinking?.[role];
+    return thinking === undefined ? { model } : { model, thinking };
+  };
+  const home = input.subagent && config.subagent !== undefined ? forRole("subagent", config.subagent) : forRole("build", config.build);
   // Compaction summaries, and any other extension's call that names the virtual model.
-  if (input.reason === "direct") return { model: home };
+  if (input.reason === "direct") return home;
 
   // Worked out first, so an edit made on the fallback or during a retry still counts.
   const state = input.subagent ? input.state : nextState(input);
@@ -52,16 +58,16 @@ export function chooseModel(config: RouterConfig, input: RouteInput): RouteChoic
 
   if (input.reason === "retry" && input.failed) {
     const overloaded = OVERLOADED.test(input.failed.errorMessage ?? "");
-    const moves = overloaded && config.fallback !== undefined && config.fallback !== input.failed.model;
-    return { model: moves ? (config.fallback as string) : input.failed.model, ...changed };
+    if (overloaded && config.fallback !== undefined && config.fallback !== input.failed.model) return { ...forRole("fallback", config.fallback), ...changed };
+    return { model: input.failed.model, ...(input.failed.thinking === undefined ? {} : { thinking: input.failed.thinking }), ...changed };
   }
 
   // Back on the first choice at the next message, not on every tool call in between.
   if (input.reason === "continuation" && input.previous !== undefined && input.previous === config.fallback) {
-    return { model: input.previous, ...changed };
+    return { ...forRole("fallback", input.previous), ...changed };
   }
 
-  if (input.subagent) return { model: home };
-  const model = input.mode === "plan" || state?.phase === "plan" ? config.plan : config.build;
-  return { model, ...changed };
+  if (input.subagent) return home;
+  const choice = input.mode === "plan" || state?.phase === "plan" ? forRole("plan", config.plan) : forRole("build", config.build);
+  return { ...choice, ...changed };
 }

package/packages/subscription/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jarno Keskikangas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/subscription/README.md

@@ -0,0 +1,60 @@
+# pi-subscription
+
+Claude models in Pi on your Claude login, through Anthropic's Agent SDK. Pi keeps its own agent loop, tools, sessions and compaction, and Claude Code only carries the requests. It asks before anything is billed as extra usage.
+
+Based on [pi-claude-subscription](https://github.com/jkeskikangas/pi-claude-subscription) by Jarno Keskikangas, used under the MIT license.
+
+## Use it
+
+This part is off until you run `/suite on subscription`, because its models count as logged in whether you are or not, and because of the terms below. Log in to Claude Code (`claude`, then `/login`), then pick a `claude-sdk/...` model in `/model`, such as `claude-sdk/claude-sonnet-5-5`. `/suite off subscription` removes them and moves you to another model.
+
+It uses Claude Code's login, never Pi's. So that nothing else decides where your requests or login go, it removes `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_CUSTOM_HEADERS` and the Bedrock, Vertex and Foundry switches from Claude Code's environment.
+
+## Extra usage
+
+When Claude Code reports that requests are billed as extra usage, you're asked before going on:
+
+- **No, stop:** nothing more is sent, and each new message asks again, until the limit resets or a new session starts.
+- **Yes, bill extra usage for this session:** it goes on, and doesn't ask again until requests are back on your plan, or a new session starts, including `/new`, `/clear` and `/reload`.
+
+The report normally comes after the reply, so that reply is kept and the next request asks before sending anything. If a report arrives while a reply is being written, the reply is stopped. After a yes it runs again if nothing had appeared, and otherwise you send your message again.
+
+With nobody to ask, as in `pi -p` or a subagent, the answer is no.
+
+What this can't do:
+
+- **The first request over the limit is billed.** Claude Code only reports billing with a response, and in testing that report came after the whole reply, including a slow one. So one reply can be billed before you're asked, or more if a tool loop has requests in flight. Your Claude settings are the hard limit: leave extra usage off, or set a monthly cap, if that matters.
+- **It goes by what Claude Code reports.** It's been tested with the real Claude Code binary against a fake server that sends those reports, not with a real bill. Check your usage page after your first requests.
+- **The costs Pi shows are estimates** at API prices, not what your plan charges.
+
+A request can also be refused with `Third-party apps now draw from your extra usage`. Nothing runs then, and the error says what to do.
+
+## Terms
+
+Anthropic's [legal page](https://code.claude.com/docs/en/legal-and-compliance) says subscription logins are for ordinary use of Claude Code and Anthropic's own apps, and that products built on the Agent SDK should use API keys. It doesn't address a personal extension like this one, and it says Anthropic may enforce its rules without notice. So this could stop working, and the risk is to your account. An [API key](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) is the clear-cut alternative.
+
+## System prompt
+
+For `claude-sdk` models, Pi's default prompt is replaced by one written for Claude. It says it's working in Pi, and keeps every tool and guideline from Pi and other extensions, along with context files, skills and the working directory. Your own `SYSTEM.md` always wins.
+
+Requests use Pi's default prompt instead with `router/auto`, in `plan` and `read-only` modes, and when the memory part has notes to add, because those build on Pi's prompt.
+
+Anthropic's billing has been seen to depend on the prompt: upstream saw Pi's default prompt refused where this one ran on the plan. So expect the refusal above, or the question about extra usage, in those cases. To always use Pi's prompt, set **System prompt** to `pi` in `/suite`, or `PI_CLAUDE_SDK_PROMPT=pi`.
+
+## Settings
+
+All optional, in `/suite` or under `subscription` in `~/.pi/agent/suite.json`:
+
+```json
+{ "subscription": { "pathToClaudeCodeExecutable": "/opt/homebrew/bin/claude", "maxSessions": 3, "idleMinutes": 20, "promptMode": "claude" } }
+```
+
+There's no setting per project, so a repository can't choose which program runs. `PI_CLAUDE_SDK_CLAUDE_PATH` overrides the executable, and `PI_CLAUDE_SDK_DEBUG=/path/log` writes how each request was routed.
+
+## What it leaves on disk
+
+Conversations are copied into Claude Code's session files under `~/.claude/projects`, readable only by you, so they can show up in Claude Code's `/resume`. `~/.pi/agent/claude-sdk/anchors.jsonl` records where each conversation is in those files.
+
+## Dependencies
+
+It needs `@anthropic-ai/claude-agent-sdk`, pinned to an exact version and loaded only on the first request to one of these models. That package includes a Claude Code binary of about 270 MB for your platform. npm also installs what it lists as required, including the MCP SDK and through it `express` and `hono`. Nothing here loads those: this part has its own small tool server, and the Agent SDK bundles its own copy.

package/packages/subscription/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@huseynsnmz/pi-subscription",
+  "version": "0.1.0",
+  "description": "Claude models in Pi on your Claude login, asking before anything is billed as extra usage.",
+  "type": "module",
+  "license": "MIT",
+  "private": true,
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "node --test --test-timeout=20000 test/*.test.ts"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "1.5.0",
+    "@earendil-works/pi-coding-agent": "1.5.0",
+    "@types/node": "26.6.6",
+    "typebox": "1.4.3",
+    "typescript": "7.0.2"
+  }
+}

package/packages/subscription/src/anchors.ts

@@ -0,0 +1,75 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Where a conversation state lives in Claude Code's own session files: after the assistant
+ * message `messageId` of session `sessionId`. Keyed by the pi transcript chain hash, so a pi
+ * session that diverges from a live Claude Code process (abort, branch, restart) resumes the
+ * exact bytes Claude Code sent before and keeps its prompt cache. `entryUuid` is the Claude
+ * Code transcript-entry uuid streamed with that message; anchors written before it was
+ * captured carry only the API message id and are resolved by scanning the transcript.
+ */
+export interface Anchor {
+	sessionId: string;
+	messageId: string;
+	cwd: string;
+	entryUuid?: string;
+}
+
+const MAX_ENTRIES = 20_000;
+/** It names your folders and sessions. */
+const PRIVATE = 0o600;
+
+export class AnchorRegistry {
+	private map = new Map<string, Anchor>();
+	private loaded = false;
+
+	private readonly file: string;
+
+	constructor(file = join(getAgentDir(), "claude-sdk", "anchors.jsonl")) {
+		this.file = file;
+	}
+
+	private load(): void {
+		if (this.loaded) return;
+		this.loaded = true;
+		if (!existsSync(this.file)) return;
+		const lines = readFileSync(this.file, "utf8").split("\n");
+		for (const line of lines) {
+			if (!line) continue;
+			try {
+				const { k, s, m, c, u } = JSON.parse(line);
+				this.map.set(k, { sessionId: s, messageId: m, cwd: c, ...(typeof u === "string" ? { entryUuid: u } : {}) });
+			} catch {}
+		}
+		if (lines.length > MAX_ENTRIES * 2) this.compact();
+	}
+
+	private compact(): void {
+		const entries = [...this.map.entries()].slice(-MAX_ENTRIES);
+		this.map = new Map(entries);
+		writeFileSync(this.file, entries.map(([k, a]) => line(k, a)).join(""), { mode: PRIVATE });
+	}
+
+	get(key: string): Anchor | undefined {
+		this.load();
+		return this.map.get(key);
+	}
+
+	put(key: string, anchor: Anchor): void {
+		this.load();
+		this.map.delete(key);
+		this.map.set(key, anchor);
+		try {
+			mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
+			appendFileSync(this.file, line(key, anchor), { mode: PRIVATE });
+		} catch {
+			// Persistence is an optimization; the in-memory map still serves this process.
+		}
+	}
+}
+
+function line(k: string, a: Anchor): string {
+	return `${JSON.stringify({ k, s: a.sessionId, m: a.messageId, c: a.cwd, ...(a.entryUuid ? { u: a.entryUuid } : {}) })}\n`;
+}

package/packages/subscription/src/billing.ts

@@ -0,0 +1,39 @@
+// How Claude Code says a request is billed. Its rate_limit_event arrives with the response, so the
+// first such request can only be stopped once it has started. Later ones are asked about first.
+export interface RateLimitInfo {
+	status?: string;
+	resetsAt?: number;
+	overageResetsAt?: number;
+	rateLimitType?: string;
+	isUsingOverage?: boolean;
+	overageInUse?: boolean;
+}
+
+export function billsExtraUsage(info: RateLimitInfo | undefined): boolean {
+	if (info === undefined) return false;
+	// Over the plan's limit the status is "rejected", yet the request is served from extra usage.
+	if (info.isUsingOverage === true) return true;
+	return info.status !== "rejected" && (info.overageInUse === true || info.rateLimitType === "overage");
+}
+
+export const EXTRA_USAGE_QUESTION = "Claude says requests are now billed as extra usage, beyond your plan's limits. Nothing more is sent unless you allow it. Allow it?";
+export const EXTRA_USAGE_NO = "No, stop";
+export const EXTRA_USAGE_YES = "Yes, bill extra usage for this session";
+
+export const EXTRA_USAGE_STOPPED = "Stopped, because requests are billed as extra usage and it wasn't approved. Anything used before it stopped may still be billed.";
+export const EXTRA_USAGE_RESEND = "Extra usage is approved for this session. The reply had already started, so send your message again.";
+
+/** Whether this report still holds. With no end time to go by, it holds until a request says otherwise. */
+export function stillBilling(info: RateLimitInfo | undefined, nowSeconds: number): boolean {
+	if (info === undefined) return false;
+	const until = info.resetsAt;
+	return until === undefined || until > nowSeconds;
+}
+
+const THIRD_PARTY = /third-party apps now draw from your extra usage/i;
+
+/** Claude's wording alone doesn't say what happened to the request, or what to do about it. */
+export function explainError(text: string): string {
+	if (!THIRD_PARTY.test(text)) return text;
+	return `${text}\nAnthropic refused this request as third-party use. To go on, turn on extra usage in your Claude settings or choose another model. You'll be asked here before it's billed.`;
+}