@llblab/pi-kit 0.31.1 → 0.32.0

package/BACKLOG.md

@@ -1,6 +1,6 @@
 # Backlog
 
-The 0.31.1 composition advances Telegram to 0.54.3; package pins, resource order and bundled runtime ownership remain authoritative in `package.json`. Release outcomes belong in [CHANGELOG.md](./CHANGELOG.md).
+The 0.32.0 composition advances Codex Usage to 0.13.0; package pins, resource order and bundled runtime ownership remain authoritative in `package.json`. Release outcomes belong in [CHANGELOG.md](./CHANGELOG.md).
 
 ## Carried checks
 

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.32.0: OpenAI Subscription Quota Support
+
+- `OpenAI Subscription Support`: Advances Codex Usage to `0.13.0`. ChatGPT subscription OAuth under `openai` now fetches Codex quotas without the legacy `openai-codex` provider; ordinary API-key auth is skipped. Both providers support terminal and Telegram status plus `/fast`, with preferences isolated by provider/model. Other pins, package membership, resources and load order are unchanged.
+
+## 0.31.2: Telegram Restore Flow
+
+- `Telegram Restore Flow`: Advances the exact Telegram pin to `0.54.4`. Restoring a Pi into a routing tab renames the tab to that Pi's Thread title and keeps the prompt it answers, since an input sent from `All` now moves into its routing tab on desktop and mobile alike. Routing menus disappear after every final choice, every client ends with one routing tab per `All` input, and the old tab is removed right after Pi answers. Other pins, package membership, resources and load order are unchanged.
+
 ## 0.31.1: Telegram Mobile Routing Tab
 
 - `Telegram Mobile Routing`: Advances the exact Telegram pin to `0.54.3`. Sending a command or prompt from `All` in mobile Telegram no longer leaves an extra tab named after the input next to the routing tab; the native tab the mobile client creates is adopted as the routing tab. Other pins, package membership, resources and load order are unchanged.

package/README.md

@@ -15,10 +15,10 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-actors`](https://github.com/llblab/pi-actors) | `0.54.0` | Inspectable local Runs, reusable Recipes, persistent tools, and delegation Skills |
 | [`@llblab/pi-claude-usage`](https://github.com/llblab/pi-claude-usage) | `0.2.1` | Claude subscription quota status and shared per-model Fast toggle for Opus, mirrored in Telegram |
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.3.0` | Isolated nested Pi TUI with named npm extensions and compatible model selection |
-| [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.12.1` | Shared Codex quota/Business credit status and persistent priority Fast toggle, mirrored in Telegram |
+| [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.13.0` | OpenAI/legacy Codex subscription quota and Business credit status, with persistent priority Fast toggle mirrored in Telegram |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.9.0` | Visible continuation scheduling and bounded worker Skills through compiled, manifest-owned resources |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.26.4` | Scoped context/memory compiler with step-independent current memory, stable Passive/Active modes and visible blocked-state status |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.54.3` | Telegram companion with live Thread rebinding, temporary routing tabs, Workspace Restore, follower Threads, Windows support, files, voice, and controls |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.54.4` | Telegram companion with live Thread rebinding, temporary routing tabs, Workspace Restore, follower Threads, Windows support, files, voice, and controls |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.
@@ -45,7 +45,9 @@ Prefer the kit instead of separately loading the same packages. If you already u
 
 ## Development
 
-The `0.31.1` composition carries Telegram `0.54.3`, which keeps mobile Telegram to one routing tab per `All` input, on top of `0.54.2`: an idle connected session no longer writes to disk periodically (the update journal has its own lock instead of the `telegram.json` guard, the leader proves liveness over the bus instead of a two-second `state.json` heartbeat), followers go offline instead of looping when Threaded Mode is switched off, unverifiable ownership checks are recorded and tolerated, and cancelled Generative App methods cannot leave processes behind. Telegram 0.54 uses bus protocol v3: update every Pi process that runs pi-telegram together, because a 0.53.x follower cannot register with a 0.54 leader. State Flow stays at `0.26.4`; all other pins, resources and load order remain unchanged. Telegram runtime storage stays in `tmp/pi-telegram`. Drain the prompt queue or accept losing waiting work before reload/restart; damaged-state reset discards all profiles' runtime continuity. `npm run validate` checks exact installed pins, declared resources, dependency audit and bundled inventory. It does not certify installed-client rendering; carried checks remain in [Backlog](./BACKLOG.md).
+The `0.32.0` composition advances Codex Usage to `0.13.0`: subscription OAuth under `openai` can fetch the existing Codex quota without the legacy `openai-codex` provider, while ordinary API-key credentials are skipped. Terminal status, Telegram quota/Fast status and `/fast` support both providers, with Fast preferences isolated by provider/model. Other pins, resource paths and load order are unchanged.
+
+Telegram `0.54.4` moves an `All` input into its routing tab, renames a restored tab to its Pi's Thread title, keeps routing menus one-shot and removes the old tab right after Pi answers, and `0.54.3`, which keeps mobile Telegram to one routing tab per `All` input, on top of `0.54.2`: an idle connected session no longer writes to disk periodically (the update journal has its own lock instead of the `telegram.json` guard, the leader proves liveness over the bus instead of a two-second `state.json` heartbeat), followers go offline instead of looping when Threaded Mode is switched off, unverifiable ownership checks are recorded and tolerated, and cancelled Generative App methods cannot leave processes behind. Telegram 0.54 uses bus protocol v3: update every Pi process that runs pi-telegram together, because a 0.53.x follower cannot register with a 0.54 leader. State Flow stays at `0.26.4`; all other pins, resources and load order remain unchanged. Telegram runtime storage stays in `tmp/pi-telegram`. Drain the prompt queue or accept losing waiting work before reload/restart; damaged-state reset discards all profiles' runtime continuity. `npm run validate` checks exact installed pins, declared resources, dependency audit and bundled inventory. It does not certify installed-client rendering; carried checks remain in [Backlog](./BACKLOG.md).
 
 ```bash
 npm install

package/node_modules/@llblab/pi-codex-usage/AGENTS.md

@@ -5,7 +5,8 @@
 - `Domain DAG`: `index.ts` only re-exports the extension and public contracts; `lib/extension.ts` composes the Pi extension. `lib/usage-store.ts` owns persistence/leadership, `lib/query.ts` owns quota I/O, `lib/usage.ts` owns normalized reports, `lib/status.ts` and `lib/status-format.ts` own local UI orchestration and formatting, `lib/telegram.ts` owns optional registration, and `lib/fast.ts` owns Codex Fast semantics/request adaptation. `@llblab/pi-command-fast` owns command arbitration and generic JSONC override editing. Keep dependency direction acyclic; do not import `index.ts` from `lib/` or mix Fast persistence into quota coordination. Place domain tests in `tests/<domain>.test.ts` (or a domain-prefixed focused integration test); use independent names such as `invariants.test.ts` only for cross-domain invariants.
 - `Statusline-first scope`: Own usage state + usage mode: keep quota reporting zero-configuration and the optional Fast toggle focused on the existing terminal status.
   - Trigger: Considering new commands, menus, persisted settings, or notification output.
-  - Action: Prefer deleting the surface unless it is required for the optimistic TUI status widget, the optional `pi-telegram` `/start` status-line mirror, or the existing argument-free `/fast` command. Register the `openai-codex` provider handler through `registerFastProvider` on session_start and release on session_shutdown; never register `/fast` directly or filter Fast by model ID/auth. Fast persists solely as `serviceTier: "priority"` in the current model override; OFF deletes only that property. Preserve JSONC/unrelated settings, existing wire tiers, and usage refresh/Telegram. Apply lowercase ` fast` through the final terminal boundary; the optional Telegram row reads the active model's Fast preference at render time and appends plain-text ` fast` (or shows `fast` alone without quota). Toggle redraws without quota fetch or success notification. The library owns session WeakMap/reload arbitration, not Fast state. A Fast config read failure must not block usage status.
+  - Action: Prefer deleting the surface unless it is required for the optimistic TUI status widget, the optional `pi-telegram` `/start` status-line mirror, or the existing argument-free `/fast` command. Register both `openai-codex` and `openai` provider handlers through `registerFastProvider` on session_start and release both on session_shutdown; never register `/fast` directly or filter Fast by model ID/auth. Fast persists solely as `serviceTier: "priority"` in the current provider/model override (never share preferences across providers with the same model ID); OFF deletes only that property. Preserve JSONC/unrelated settings, existing wire tiers, and usage refresh/Telegram. Apply lowercase ` fast` through the final terminal boundary; the optional Telegram row reads the active model's Fast preference at render time and appends plain-text ` fast` (or shows `fast` alone without quota). Toggle redraws without quota fetch or success notification. The library owns session WeakMap/reload arbitration, not Fast state. A Fast config read failure must not block usage status.
+- `OpenAI provider support`: Show the same Codex subscription quota for active `openai-codex` and `openai` models. Quota transport accepts `openai` subscription OAuth (guarded by `modelRegistry.isUsingOAuth`) and legacy `openai-codex` auth, with the Codex CLI fallback; never send `openai` API-key credentials to the ChatGPT quota endpoint or label Codex quotas as API billing limits.
 - `Optimistic refresh`: Preserve the last good statusline bar during refresh and transient failures.
   - Trigger: Updating quota polling or error handling.
   - Action: Do not collapse the bar while a request is in flight; only show `n/a` or `error` after repeated failures or no usable quota.

package/node_modules/@llblab/pi-codex-usage/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.13.0: OpenAI Subscription Provider Support
+
+- Added `openai` alongside `openai-codex` for `/fast`, request priority adaptation, terminal status and the optional Telegram row. Fast preferences remain isolated by provider/model, including identical model IDs. Both providers share the existing Codex subscription quota stream. Pi subscription OAuth under `openai` now fetches quota directly without requiring the legacy provider; `openai` API-key auth is skipped and the Codex CLI fallback is preserved.
+
 ## 0.12.1: Telegram Fast Status
 
 - The optional Telegram status row now appends lowercase ` fast` for the active Codex model, or shows `fast` alone when quota is unavailable. It rereads the per-model preference at menu render time, so toggles, model changes and manual edits do not wait for quota refresh. Quota polling, auth, request adaptation and terminal behavior are unchanged; isolated tests cover enabled/disabled state, model/provider changes and unreadable configuration.

package/node_modules/@llblab/pi-codex-usage/README.md

@@ -19,16 +19,16 @@ This repository is a minimal fork of [`narumiruna/pi-extensions/extensions/pi-co
 - Shows two counter-moving half-height markers in the statusline bar while Codex usage is loading, then keeps the bar fresh (the countdown ticks locally)
 - Keeps the last usable bar visible during ordinary refreshes instead of replacing known quota with a loading state
 - Statusline output adapts to the response: weekly-only limits show an explicit remaining percentage and reset countdown, while dual-window limits keep the compact themed bar
-- All Codex subscription models share the primary `codex` quota and status label
-- When `pi-telegram` is available, the same compact value appears as `codex: <value>` in the `/start` menu status text for active OpenAI Codex subscription models
+- Models under either `openai-codex` or `openai` show the same primary Codex subscription quota and `codex` status label (not OpenAI API billing limits)
+- When `pi-telegram` is available, the same compact value appears as `codex: <value>` in the `/start` menu status text for either supported provider
 - Additional returned quota buckets are ignored
-- Pi OpenAI Codex provider auth is used first
+- Pi subscription auth from `openai` or legacy `openai-codex` is used first
 - Codex CLI app-server remains available as a fallback
 - Missing auth, subscription, plan, or quota windows are shown as `n/a`, not as an error
 - Successful updates briefly redraw the bar only when a 5% segment changes
 - Network/provider failures keep the last good bar (up to an hour), then show `error`
 - Any number of Pi instances share one request stream, see [Shared Refresh](#shared-refresh)
-- Quota display requires no configuration; `/fast` optionally toggles priority service for the active native Codex model
+- Quota display requires no configuration; `/fast` optionally toggles priority service for the active `openai-codex` or `openai` model
 
 ## Install
 
@@ -59,7 +59,7 @@ For explicitly local library experiments, a temporary folder link reads the libr
 
 ## Fast mode
 
-`/fast` takes no arguments and dispatches by the current **provider**, not model names or OAuth eligibility. For any `openai-codex` model, it stores only `serviceTier: "priority"` in Pi's canonical `models.json` (honoring `PI_CODING_AGENT_DIR`):
+`/fast` takes no arguments and dispatches by the current **provider**, not model names or OAuth eligibility. For any `openai-codex` or `openai` model, it stores only `serviceTier: "priority"` in Pi's canonical `models.json` (honoring `PI_CODING_AGENT_DIR`):
 
 ```json
 {
@@ -73,6 +73,8 @@ For explicitly local library experiments, a temporary folder link reads the libr
 }
 ```
 
+For an `openai` model, the same override goes under `providers.openai.modelOverrides`. Preferences are isolated by provider and model ID, so identical IDs in the two providers do not share Fast state.
+
 OFF removes only `serviceTier`; it never writes `"default"`. JSONC comments and unrelated configuration survive. There is no separate Fast config or model allowlist. State follows provider/model selection and survives restart; manual edits are read on lifecycle refresh and each request.
 
 When this and Claude Usage are loaded, their shared library registers **one** `/fast`, in either load order, even with separate physical dependency copies. A session-scoped WeakMap avoids cross-session dispatch; shutdown releases registrations for reload (Pi retains the session manager). Unrelated providers receive a concise unsupported-provider message. Invalid arguments show `Usage: /fast`; success is silent.
@@ -155,22 +157,22 @@ Coordination assumes a local filesystem and cooperating instances on the same ma
 
 ## Telegram Status Menu
 
-If `@llblab/pi-telegram` is loaded with the public status-line provider API, this extension registers an optional `/start` menu status row. The row is shown only while the active model uses the OpenAI Codex subscription provider:
+If `@llblab/pi-telegram` is loaded with the public status-line provider API, this extension registers an optional `/start` menu status row. The row is shown only while the active model uses `openai-codex` or `openai`:
 
 ```text
 codex: ██████▀▀▀▀ 6d
 ```
 
-The value is the same compact quota bar plus weekly reset countdown used by the terminal statusline, always with the `codex` label. When Fast is enabled for the active model, it appends plain-text ` fast`; without a usable quota report it shows `codex: fast`. The preference is reread when the menu is rendered, so toggles and model changes do not depend on a quota refresh. If `pi-telegram` is absent, older, or the active model is not a Codex subscription model, no Telegram row is added.
+The value is the same compact quota bar plus weekly reset countdown used by the terminal statusline, always with the `codex` label. When Fast is enabled for the active model, it appends plain-text ` fast`; without a usable quota report it shows `codex: fast`. The preference is reread when the menu is rendered, so toggles and model changes do not depend on a quota refresh. If `pi-telegram` is absent, older, or the active model uses another provider, no Telegram row is added.
 
 ## Auth
 
 The extension tries usage sources in this order:
 
-1. Pi's `openai-codex` provider auth
+1. Pi's subscription auth from `openai` or legacy `openai-codex` (active model first)
 2. `codex app-server --listen stdio://`
 
-OpenAI API keys are not ChatGPT Codex subscription auth and do not expose these quotas.
+Selecting an `openai` model enables the status and Fast toggle, and its ChatGPT subscription OAuth credentials can fetch the quota directly; a legacy `openai-codex` provider is not required. The extension uses Pi's resolved auth headers/token, checks `modelRegistry.isUsingOAuth` before using `openai` credentials, and keeps the Codex CLI fallback. OpenAI API keys are not ChatGPT subscription auth and do not expose these quotas; `openai` API-key credentials are skipped, not sent to the ChatGPT quota endpoint. Without subscription auth/quota, the quota status is `n/a` when both sources report an unavailable state. Fast works independently of subscription auth.
 
 ## License
 

package/node_modules/@llblab/pi-codex-usage/lib/extension.ts

@@ -3,23 +3,26 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerFastProvider } from "@llblab/pi-command-fast";
 import { applyFastToRequest, isFastEnabled, isFastEligibleModel, toggleFast } from "./fast.ts";
 import { createCodexUsageStatus } from "./status.ts";
+import { OPENAI_USAGE_PROVIDERS } from "./usage.ts";
 
 export default function codexUsage(pi: ExtensionAPI) {
-  let releaseFast: (() => void) | undefined;
+  let releaseFast: Array<() => void> = [];
   pi.on("session_start", (_event, ctx) => {
-    releaseFast = registerFastProvider(pi, ctx, {
-      provider: "openai-codex",
-      toggle(commandCtx) {
-        toggleFast(commandCtx.model!.id);
-        status.fastChanged(commandCtx, commandCtx.model!);
-      },
-    });
+    for (const provider of OPENAI_USAGE_PROVIDERS) {
+      releaseFast.push(registerFastProvider(pi, ctx, {
+        provider,
+        toggle(commandCtx) {
+          toggleFast(commandCtx.model!);
+          status.fastChanged(commandCtx, commandCtx.model!);
+        },
+      }));
+    }
   });
-  pi.on("session_shutdown", () => { releaseFast?.(); releaseFast = undefined; });
+  pi.on("session_shutdown", () => { releaseFast.forEach((release) => release()); releaseFast = []; });
   const status = createCodexUsageStatus(pi);
   pi.on("before_provider_request", (event, ctx) => {
     const model = ctx.model;
     if (!isFastEligibleModel(model)) return;
-    return applyFastToRequest(event.payload, model.id, isFastEnabled(model.id));
+    return applyFastToRequest(event.payload, model.id, isFastEnabled(model));
   });
 }

package/node_modules/@llblab/pi-codex-usage/lib/fast.ts

@@ -3,16 +3,17 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isModelOverrideValue, toggleModelOverrideValue } from "@llblab/pi-command-fast";
 import { isOpenAICodexModel } from "./usage.ts";
 
-const target = (id: string) => ({ provider: "openai-codex", id, property: "serviceTier", enabledValue: "priority" });
+type FastModel = Pick<NonNullable<ExtensionContext["model"]>, "provider" | "id">;
+const target = (model: FastModel) => ({ provider: model.provider, id: model.id, property: "serviceTier", enabledValue: "priority" });
 
 export function isFastEligibleModel(model: ExtensionContext["model"]): model is NonNullable<ExtensionContext["model"]> {
   return !!model && isOpenAICodexModel(model);
 }
-export function isFastEnabled(modelId: string, path?: string): boolean {
-  return isModelOverrideValue(target(modelId), path);
+export function isFastEnabled(model: FastModel, path?: string): boolean {
+  return isModelOverrideValue(target(model), path);
 }
-export function toggleFast(modelId: string, path?: string): boolean {
-  return toggleModelOverrideValue(target(modelId), path);
+export function toggleFast(model: FastModel, path?: string): boolean {
+  return toggleModelOverrideValue(target(model), path);
 }
 
 export function applyFastToRequest(payload: unknown, modelId: string, enabled: boolean): unknown {

package/node_modules/@llblab/pi-codex-usage/lib/query.ts

@@ -2,8 +2,7 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { assertObject, errorMessage, normalizeAppServerResponse, normalizeBackendPayload, parseJsonObject, selectUsageSnapshot, type AppServerRateLimitResponse, type CodexUsageModel, type CodexUsageReport, type RateLimitStatusPayload, type UsageQueryError } from "./usage.ts";
-const CODEX_PROVIDER_ID = "openai-codex";
+import { assertObject, errorMessage, isOpenAICodexModel, normalizeAppServerResponse, normalizeBackendPayload, parseJsonObject, selectUsageSnapshot, type AppServerRateLimitResponse, type CodexUsageModel, type CodexUsageReport, type RateLimitStatusPayload, type UsageQueryError } from "./usage.ts";
 const CODEX_USAGE_LIMIT_ID = "codex";
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const MAX_ERROR_BODY_CHARS = 600;
@@ -64,7 +63,7 @@ async function queryViaPiAuth(
   const auth = await resolvePiCodexAuth(ctx);
   if (!auth) {
     throw new Error(
-      "No Pi OpenAI Codex subscription auth was available. Use a Pi OpenAI Codex model or run /login for OpenAI ChatGPT Plus/Pro (Codex).",
+      "No Pi OpenAI Codex subscription auth was available. Use an openai or openai-codex subscription model or run /login for OpenAI ChatGPT.",
     );
   }
 
@@ -96,6 +95,7 @@ async function resolvePiCodexAuth(
   const errors: string[] = [];
 
   for (const model of models) {
+    if (model.provider === "openai" && !ctx.modelRegistry.isUsingOAuth(model)) continue;
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
     if (!auth.ok) {
       errors.push(auth.error);
@@ -127,7 +127,7 @@ function codexAuthCandidateModels(ctx: ExtensionContext): PiModel[] {
   const candidates: PiModel[] = [];
   const seen = new Set<string>();
   const add = (model: PiModel | undefined) => {
-    if (!model || model.provider !== CODEX_PROVIDER_ID) return;
+    if (!model || !isOpenAICodexModel(model)) return;
     const key = `${model.provider}/${model.id}`;
     if (seen.has(key)) return;
     seen.add(key);

package/node_modules/@llblab/pi-codex-usage/lib/status.ts

@@ -41,20 +41,20 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
   let statuslineRequestId = 0;
   let unregisterTelegramStatusLine: (() => void) | undefined;
   let telegramStatusLineRegistration: Promise<void> | undefined;
-  let fastModelId: string | undefined;
+  let fastModel: PiModel | undefined;
   let fastEnabled = false;
   let lastStatusText: string | undefined;
   let loadingModel: CodexUsageModel | undefined;
 
-  const syncFast = (model: PiModel | undefined, ctx: ExtensionContext) => {
-    fastModelId = isFastEligibleModel(model) ? model.id : undefined;
-    fastEnabled = fastModelId !== undefined && isFastEnabled(fastModelId);
+  const syncFast = (model: PiModel | undefined) => {
+    fastModel = isFastEligibleModel(model) ? model : undefined;
+    fastEnabled = fastModel !== undefined && isFastEnabled(fastModel);
   };
   const setCodexStatus = (ctx: ExtensionContext, text: string | undefined, model?: CodexUsageModel) => {
     lastStatusText = text;
     ctx.ui.setStatus(STATUS_KEY, text === undefined ? undefined : appendFastStatus(
       ctx, text,
-      fastEnabled && model?.id === fastModelId,
+      fastEnabled && model?.provider === fastModel?.provider && model?.id === fastModel?.id,
     ));
   };
 
@@ -95,7 +95,7 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
     ctx: ExtensionContext,
     model: CodexUsageModel | undefined,
   ) => {
-    const modelChanged = loadingModel?.id !== model?.id;
+    const modelChanged = loadingModel?.provider !== model?.provider || loadingModel?.id !== model?.id;
     loadingModel = model;
     if (statuslineLoadingTimer) {
       if (modelChanged && lastStatusText !== undefined) setCodexStatus(ctx, lastStatusText, model);
@@ -331,7 +331,7 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
     try {
       const activeModel = model ?? ctx.model;
       const previousFast = fastEnabled;
-      syncFast(activeModel, ctx);
+      syncFast(activeModel);
       forceRender ||= previousFast !== fastEnabled;
       if (!isOpenAICodexModel(activeModel)) {
         clearUsageStatusline(ctx);
@@ -370,7 +370,7 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
   ensureTelegramStatusLineRegistered();
 
   pi.on("session_start", (_event, ctx) => {
-    syncFast(ctx.model, ctx);
+    syncFast(ctx.model);
     ensureTelegramStatusLineRegistered();
     if (isOpenAICodexModel(ctx.model))
       void refreshCurrentCodexUsageStatusline(ctx, true).catch(
@@ -388,7 +388,7 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
   });
 
   pi.on("model_select", (event, ctx) => {
-    syncFast(event.model, ctx);
+    syncFast(event.model);
     if (isOpenAICodexModel(event.model)) {
       void refreshCurrentCodexUsageStatusline(ctx, true, event.model).catch(
         handleAsyncTimerError,
@@ -405,7 +405,7 @@ export function createCodexUsageStatus(pi: ExtensionAPI) {
   });
   return {
     fastChanged(ctx: ExtensionContext, model: PiModel) {
-      syncFast(model, ctx);
+      syncFast(model);
       if (lastStatusText !== undefined) setCodexStatus(ctx, lastStatusText, model);
       renderState(ctx, loadState(), model, true);
     },

package/node_modules/@llblab/pi-codex-usage/lib/telegram.ts

@@ -29,7 +29,7 @@ export function codexUsageTelegramStatusLine(
 ): TelegramStatusLineProviderResult {
   if (!activeModel || !isOpenAICodexModel(activeModel)) return undefined;
   const value = report ? formatCodexUsageStatusValue(report, activeModel) : undefined;
-  const fast = isFastEnabled(activeModel.id);
+  const fast = isFastEnabled(activeModel);
   if (!value && !fast) return undefined;
   return { label: "codex", value: value ? `${value}${fast ? " fast" : ""}` : "fast" };
 }

package/node_modules/@llblab/pi-codex-usage/lib/usage.ts

@@ -4,8 +4,9 @@ const SECOND_MS = 1000;
 const CODEX_USAGE_LIMIT_ID = "codex";
 type PiModel = NonNullable<ExtensionContext["model"]>;
 export type CodexUsageModel = Pick<PiModel, "id" | "name" | "provider">;
+export const OPENAI_USAGE_PROVIDERS = ["openai-codex", "openai"] as const;
 export function isOpenAICodexModel(model: Pick<PiModel, "provider"> | undefined): boolean {
-  return model?.provider === "openai-codex";
+  return OPENAI_USAGE_PROVIDERS.some((provider) => model?.provider === provider);
 }
 export type UsageSource = "pi-auth" | "codex-app-server";
 export type UsageQueryError = { source: UsageSource; message: string; cause?: unknown };

package/node_modules/@llblab/pi-codex-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "private": false,
   "description": "Pi extension for Codex subscription usage and an optional Fast toggle",
   "keywords": [

package/node_modules/@llblab/pi-telegram/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 ## Unreleased
 
+## 0.54.4: Restored tabs take their Pi's name
+
+- `Restore title`: Restoring a Pi into a routing tab ("move Pi into this tab") now renames the tab to that Pi's Thread display title, as Workspace Restore already did; previously a live-rebind Restore left the tab named `🚦 Routing`. A failed rename is recorded and never blocks the Restore.
+- `Native routing tabs`: An `All` input now also adopts a generically named native tab (desktop `New Chat`) that its client created immediately before it, not only a tab named after the input (mobile). Desktop and Android clients, with user topic creation allowed or not, each end with exactly one routing tab; a client's own brief native name before the rename cannot be prevented.
+- `Reclaimed leader tab`: When the leader's own tab is gone (for example after deleting every tab) and a new tab from `All` is reclaimed for it, the leader's Workspace binding now moves to that tab with its slot and name instead of gaining a second slot, and the tab is renamed to its display title instead of staying `New Chat`. Restore and labels no longer point at the deleted tab.
+- `Display titles`: A Thread whose tab has no acknowledged title yet (fresh, moved or reclaimed) now shows its display-mode title, such as the directory title, in the Restore menu and after Restore, instead of falling back to its generated slot name.
+- `One-shot routing menus`: Every final routing choice now deletes its menu. A live-rebind Restore left the chooser in the tab, a Workspace Restore kept it until old-Thread cleanup, which may never come, and Cancel replaced it with a notice. A restored tab stays as the Pi's Thread; a routing tab with nothing left to route is still removed. A delivered Workspace Restore answers `Restored`, not `Restore unconfirmed`, and the Restore submenu now reads `🔁 Restore a Pi into this tab:`.
+- `Restore history`: An input sent from `All` now moves into the routing tab opened for it, on desktop and mobile alike: the tab starts with a silent forward of the input, its menu replies to it, and the original leaves `All` once the copy is confirmed. A Thread restored into that tab keeps the prompt it answers instead of losing it, since the Bot API files such inputs in `All` even when mobile first draws them in the tab.
+- `Old tab cleanup`: After a live-rebind Restore, the old tab is deleted right after Pi finishes answering the moved input, instead of at the next paced retry, which could add up to about 30 seconds and later a full minute. Cleanup still waits for an idle session; a settled agent only wakes the waiting retry early.
+
 ## 0.54.3: One routing tab on mobile
 
 - `Mobile routing tab`: Sending a command or prompt from `All` in mobile Telegram no longer leaves an extra tab named after the input. The mobile client creates that native tab itself before delivering the input to `All`; the bridge now adopts it as the routing tab and renames it, instead of creating a second tab beside it. Desktop behavior is unchanged.

package/node_modules/@llblab/pi-telegram/dist/lib/bindings.d.ts

@@ -291,6 +291,8 @@ interface TelegramLifecycleBindingDeps {
     isTurnTransportActive?: (turn: Queue.PendingTelegramTurn) => boolean;
     updateStatus: TelegramBridgeStatusUpdater;
     recordRuntimeEvent: TelegramRuntimeEventRecorder;
+    /** Settled-session hint for owners that wait on agent idleness, such as old-tab cleanup after a live rebind. */
+    onSessionSettled?: (ctx: Pi.ExtensionContext) => void;
 }
-export declare function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive, isTurnTransportActive, updateStatus, recordRuntimeEvent, }: TelegramLifecycleBindingDeps): void;
+export declare function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive, isTurnTransportActive, updateStatus, recordRuntimeEvent, onSessionSettled, }: TelegramLifecycleBindingDeps): void;
 export {};

package/node_modules/@llblab/pi-telegram/dist/lib/bindings.js

@@ -626,7 +626,7 @@ export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, pe
         },
     });
 }
-export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive = () => true, isTurnTransportActive, updateStatus, recordRuntimeEvent, }) {
+export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive = () => true, isTurnTransportActive, updateStatus, recordRuntimeEvent, onSessionSettled, }) {
     const agentEndResetter = Runtime.createTelegramAgentEndResetter({
         abort,
         typing,
@@ -1077,6 +1077,7 @@ export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime,
             agentWorkActive = false;
             activityRuntime.onAgentSettled();
             modelContextAvailabilityRuntime.reconcile();
+            onSessionSettled?.(ctx);
         },
         onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({
             reconcileAvailability: modelContextAvailabilityRuntime.reconcile,

package/node_modules/@llblab/pi-telegram/dist/lib/extension.js

@@ -478,6 +478,13 @@ export default function (pi) {
         instanceId: telegramInstanceId,
         listRecords: threadStore.list,
         listWorkspaceBindings: threadStore.listWorkspaceBindings,
+        resolveAutomaticDisplayTitle(binding) {
+            return ThreadDisplay.resolveTelegramInitialWorkspaceDisplayName({
+                bindings: threadStore.listWorkspaceBindings(),
+                binding,
+                mode: Config.resolveTelegramThreadDisplayMode(configStore.get()),
+            });
+        },
         getFollowerDisplayTitle: telegramBusFollowerRegistrationState.getDisplayTitle,
         getActiveTurnTarget: activeTurnRuntime.getTarget,
         getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
@@ -2440,5 +2447,6 @@ export default function (pi) {
         },
         updateStatus,
         recordRuntimeEvent,
+        onSessionSettled: inboundRouteRuntime.onSessionSettled,
     });
 }

package/node_modules/@llblab/pi-telegram/dist/lib/routing.d.ts

@@ -57,7 +57,10 @@ export type TelegramLiveRebindCleanupIssue = {
     cleanup: ThreadReconciler.TelegramLiveRebindCleanupOutcome;
     recorded: boolean;
 };
-/** Default live-rebind cleanup pacing: quick early attempts, then minutely, within a 15-minute window. */
+/**
+ * Default live-rebind cleanup pacing: quick early attempts, then minutely, within a 15-minute window. The first
+ * delay is not cosmetic: a leader's detached command reply still needs the released, cleanup-free row.
+ */
 export declare const TELEGRAM_LIVE_REBIND_CLEANUP_SCHEDULE: Readonly<{
     delaysMs: readonly number[];
     intervalMs: 60000;
@@ -100,6 +103,8 @@ export declare function createTelegramLiveRebindCoordinator(input: {
         /** Explicit staged singleton command branch; absence preserves ordinary live input behavior. */
         selectedCommand?: Bus.TelegramBusSelectedCommandInput;
     };
+    /** Restore moves the tab to its new owner: once applied, show that owner's title (best-effort, never blocking). */
+    retitle?: (isCurrent: () => boolean) => Promise<void>;
     recordRuntimeEvent?: (category: string, error: unknown, details: Record<string, unknown>) => void;
 }): {
     /** Correlation only; a later cleanup attempt rereads and revalidates the canonical row itself. */
@@ -346,6 +351,8 @@ export declare function createTelegramInboundRouteRuntime<TUpdate extends Update
     /** Commands-owned registry port for dormant scoped recipient assembly, not ordinary update replay. */
     prepareHeldCommand: ReturnType<typeof Commands.createTelegramCommandHandlerTargetRuntime<TMessage, TContext>>["prepareHeldCommand"];
     canPrepareHeldCommand: ReturnType<typeof Commands.createTelegramCommandHandlerTargetRuntime<TMessage, TContext>>["canPrepareHeldCommand"];
+    /** Agent-settled hint: wakes waiting leader cleanup retries early; every readiness gate is still sampled fresh. */
+    onSessionSettled(ctx: TContext): void;
     /** Fresh body-free recipient observation only; never reconstructs an attempt or grants cleanup. */
     observeLiveRebindLeaderWork(intent: Threads.TelegramWorkspaceLiveRebindIntent, ctx: TContext): Promise<Bus.TelegramBusLiveRebindWorkObservation | undefined>;
     /** Fresh non-destructive candidate only; no retained idle, cleanup action or deletion grant. */