@hienlh/ppm 0.19.2 → 0.19.4

package/src/providers/codex-app-server/codex-rollout-items.ts

@@ -0,0 +1,149 @@
+import type { ChatEvent } from "../provider.interface.ts";
+import { redactTruncate } from "./codex-redact.ts";
+
+/**
+ * Rollout `item_completed` records → PPM chat events.
+ *
+ * Newer codex versions stopped writing `user_message` / `agent_message` events
+ * to the rollout and write one `item_completed` per finished item instead. The
+ * items are the same family the live app-server streams, but spelled
+ * differently: PascalCase types (`AgentMessage`, not `agentMessage`),
+ * snake_case fields (`aggregated_output`), a `command` array rather than a
+ * string, and image generation arriving as a generic `Extension` carrying a
+ * `kind`. Reading a rollout without this mapping yields nothing at all, which
+ * is why a codex conversation displayed while it was live and came back empty
+ * once it had to be read from disk.
+ *
+ * Kept separate from the rollout parser so the two spellings of the same item
+ * family do not interleave in one function.
+ */
+
+type Item = Record<string, unknown>;
+
+/** What a rollout item contributes to the reconstructed transcript. */
+export type RolloutItemMapping =
+  | { kind: "user"; text: string }
+  | { kind: "assistant"; text: string }
+  | { kind: "events"; events: ChatEvent[] }
+  | { kind: "ignore" };
+
+const IGNORED_ITEM_TYPES = new Set([
+  // Reasoning is not persisted as a message anywhere else in PPM; showing it as
+  // one would put the model's private notes in the transcript.
+  "Reasoning",
+  // Injected instructions, not part of the conversation.
+  "DeveloperMessage",
+]);
+
+function textFrom(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((c) => (c && typeof c === "object" && typeof (c as Item).text === "string" ? (c as Item).text as string : ""))
+    .filter(Boolean)
+    .join("");
+}
+
+/** `file:///C:/Users/...` → a path a person recognises. */
+function plainCwd(cwd: unknown): string | undefined {
+  if (typeof cwd !== "string" || !cwd) return undefined;
+  if (!cwd.startsWith("file://")) return cwd;
+  try {
+    const path = decodeURIComponent(new URL(cwd).pathname);
+    // Windows paths come back as `/C:/…`.
+    return /^\/[A-Za-z]:/.test(path) ? path.slice(1) : path;
+  } catch {
+    return cwd;
+  }
+}
+
+/**
+ * The command text to show. `parsed_cmd[].cmd` is the unwrapped script; the raw
+ * `command` array is the interpreter plus its arguments, whose path arrives with
+ * doubled backslashes on Windows.
+ */
+function commandText(item: Item): string {
+  const parsed = Array.isArray(item.parsed_cmd) ? item.parsed_cmd : [];
+  const parts: string[] = [];
+  for (const entry of parsed) {
+    const cmd = (entry as Item)?.cmd;
+    if (typeof cmd === "string" && cmd.trim()) parts.push(cmd);
+  }
+  if (parts.length > 0) return parts.join("\n");
+  if (Array.isArray(item.command)) return item.command.filter((c) => typeof c === "string").join(" ");
+  return typeof item.command === "string" ? item.command : "";
+}
+
+function commandExecutionEvents(item: Item): ChatEvent[] {
+  const raw = Array.isArray(item.command) ? item.command.join(" ") : String(item.command ?? "");
+  const tool = /powershell|pwsh/i.test(raw) ? "PowerShell" : "Bash";
+  const toolUseId = typeof item.id === "string" ? item.id : undefined;
+  const exit = item.exit_code;
+  return [
+    { type: "tool_use", tool, input: { command: commandText(item), cwd: plainCwd(item.cwd) }, toolUseId },
+    {
+      type: "tool_result",
+      output: redactTruncate(item.aggregated_output ?? item.stdout ?? ""),
+      isError: typeof exit === "number" && exit !== 0,
+      toolUseId,
+    },
+  ];
+}
+
+function imageGenerationEvents(item: Item): ChatEvent[] {
+  const toolUseId = typeof item.id === "string" ? item.id : undefined;
+  const failure = item.failure;
+  return [
+    {
+      // `file_path` matches what the chat's image preview already looks for, and
+      // `result` — the whole PNG as base64 — is deliberately dropped.
+      type: "tool_use",
+      tool: "ImageGen",
+      input: {
+        file_path: item.savedPath ?? null,
+        prompt: item.revisedPrompt ?? null,
+        transparentBackground: item.transparentBackground ?? false,
+      },
+      toolUseId,
+    },
+    {
+      type: "tool_result",
+      output: failure != null ? redactTruncate(failure) : String(item.savedPath ?? "generated"),
+      isError: failure != null,
+      toolUseId,
+    },
+  ];
+}
+
+/** Everything the mapping does not know, shown rather than silently dropped. */
+function genericEvents(item: Item): ChatEvent[] {
+  const toolUseId = typeof item.id === "string" ? item.id : undefined;
+  // A base64 payload would otherwise land in the transcript whole.
+  const { result: _result, ...rest } = item;
+  return [{ type: "tool_use", tool: String(item.type ?? "tool"), input: rest, toolUseId }];
+}
+
+export function mapRolloutItem(item: unknown): RolloutItemMapping {
+  if (!item || typeof item !== "object") return { kind: "ignore" };
+  const it = item as Item;
+  const type = typeof it.type === "string" ? it.type : "";
+
+  if (IGNORED_ITEM_TYPES.has(type)) return { kind: "ignore" };
+  if (type === "UserMessage") {
+    const text = textFrom(it.content);
+    return text ? { kind: "user", text } : { kind: "ignore" };
+  }
+  if (type === "AgentMessage") {
+    const text = textFrom(it.content);
+    return text ? { kind: "assistant", text } : { kind: "ignore" };
+  }
+  if (type === "CommandExecution") return { kind: "events", events: commandExecutionEvents(it) };
+  if (type === "Extension") {
+    // `kind` names the extension; image generation is the one PPM renders specially.
+    if (String(it.kind ?? "").startsWith("image_gen")) {
+      return { kind: "events", events: imageGenerationEvents(it) };
+    }
+    return { kind: "events", events: genericEvents(it) };
+  }
+  return { kind: "events", events: genericEvents(it) };
+}

package/src/providers/codex-app-server/codex-skill-parser.ts

@@ -0,0 +1,63 @@
+import type { CodexSkill, SkillListResponse } from "./codex-protocol.ts";
+
+/**
+ * Pure map of a `skills/list` response → the skills codex would actually run.
+ *
+ * The response groups skills by the cwd they were resolved for, because one
+ * app-server can hold several workspaces at once. PPM asks about a single cwd,
+ * so every group is flattened into one list.
+ *
+ * Disabled skills are dropped: codex will not run them, so offering them in the
+ * picker would produce a prompt that silently does nothing. Nameless entries
+ * are dropped for the same reason — the name is the only thing that invokes a
+ * skill.
+ *
+ * Duplicates are possible (a project-scope skill shadowing a user-scope one of
+ * the same name). First occurrence wins, matching the order codex returns.
+ */
+export function parseSkillList(res: unknown): CodexSkill[] {
+  const groups = (res as SkillListResponse | undefined)?.data;
+  if (!Array.isArray(groups)) return [];
+  const out: CodexSkill[] = [];
+  const seen = new Set<string>();
+  for (const group of groups) {
+    const skills = (group as { skills?: unknown })?.skills;
+    if (!Array.isArray(skills)) continue;
+    for (const raw of skills) {
+      if (!raw || typeof raw !== "object") continue;
+      const s = raw as Partial<CodexSkill>;
+      if (typeof s.name !== "string" || !s.name) continue;
+      if (s.enabled === false) continue;
+      if (seen.has(s.name)) continue;
+      seen.add(s.name);
+      out.push({
+        name: s.name,
+        description: typeof s.description === "string" ? s.description : undefined,
+        scope: typeof s.scope === "string" ? s.scope : undefined,
+        path: typeof s.path === "string" ? s.path : undefined,
+        // Disabled entries were skipped above, so anything reaching here is enabled.
+        enabled: true,
+        interface: parseInterface(s.interface),
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * The presentation block codex ships for its own skills — display name, one-line
+ * blurb, and icon files on disk. Every field is optional: a user-authored skill
+ * has no `interface` at all, so the caller must be able to fall back to `name`.
+ */
+function parseInterface(raw: unknown): CodexSkill["interface"] {
+  if (!raw || typeof raw !== "object") return undefined;
+  const i = raw as Record<string, unknown>;
+  const str = (v: unknown) => (typeof v === "string" && v ? v : undefined);
+  return {
+    displayName: str(i.displayName),
+    shortDescription: str(i.shortDescription),
+    iconSmall: str(i.iconSmall),
+    iconLarge: str(i.iconLarge),
+    defaultPrompt: str(i.defaultPrompt),
+  };
+}

package/src/providers/codex-app-server/codex-usage-fetch.ts

@@ -1,37 +1,39 @@
 /**
- * Shared codex quota fetcher: runs a short-lived app-server bound to a given
- * CODEX_HOME and reads account/rateLimits/read → UsageInfo. Cached per home
- * (60s) so the provider badge and the multi-account list don't spawn per call.
- * Lives here (not the provider/service) to avoid a provider↔account-service cycle.
+ * Codex quota reader: runs a short-lived app-server bound to a given CODEX_HOME
+ * and reads `account/rateLimits/read`.
+ *
+ * Deliberately uncached and unguarded — one call, one answer, throws on failure.
+ * Caching, the background sweep, the timeout, and persistence belong to the
+ * shared provider-usage layer, which reaches this through `codex-usage-source`.
+ * It lives here rather than in the provider or the account service to avoid a
+ * provider↔account-service import cycle.
  */
 import type { UsageInfo } from "../provider.interface.ts";
-import { CodexJsonRpcClient } from "./codex-jsonrpc-client.ts";
+import { CodexJsonRpcClient, CONTROL_REQUEST_TIMEOUT_MS } from "./codex-jsonrpc-client.ts";
 import { parseCodexUsage } from "./codex-usage-parser.ts";
 import type { GetAccountRateLimitsResponse } from "./codex-protocol.ts";
 
 const CLIENT_INFO = { name: "ppm", title: "PPM", version: "0.0.0" };
 const CAPABILITIES = { experimentalApi: true, requestAttestation: false, optOutNotificationMethods: null };
-const TTL = 60 * 1000;
-
-const cache = new Map<string, { usage: UsageInfo; expiry: number }>();
-
-export async function fetchCodexUsage(codexHome?: string): Promise<UsageInfo> {
-  const key = codexHome ?? "__default__";
-  const hit = cache.get(key);
-  if (hit && Date.now() < hit.expiry) return hit.usage;
 
+/**
+ * Read one codex login's quota, live.
+ *
+ * Throws on any failure — the caller distinguishes a failure from a login with
+ * nothing to report, and a swallowed error would be stored as the latter.
+ */
+export async function fetchCodexUsageLive(codexHome?: string): Promise<UsageInfo> {
   const client = new CodexJsonRpcClient();
   try {
     client.start({ cwd: process.cwd(), codexHome });
-    await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES });
+    await client.request("initialize", { clientInfo: CLIENT_INFO, capabilities: CAPABILITIES }, CONTROL_REQUEST_TIMEOUT_MS);
     client.notify("initialized");
-    const res = await client.request<GetAccountRateLimitsResponse>("account/rateLimits/read", {});
-    const usage = parseCodexUsage(res);
-    cache.set(key, { usage, expiry: Date.now() + TTL });
-    return usage;
-  } catch {
-    return {};
+    const res = await client.request<GetAccountRateLimitsResponse>("account/rateLimits/read", {}, CONTROL_REQUEST_TIMEOUT_MS);
+    return parseCodexUsage(res);
   } finally {
+    // Runs even when a request rejects on its own timeout, so a subprocess that
+    // accepted the spawn and then went silent is still killed rather than left
+    // behind. Before the client had a timeout, that was one orphan per attempt.
     client.close();
   }
 }

package/src/providers/codex-app-server/codex-usage-source.ts

@@ -0,0 +1,37 @@
+import type { UsageInfo } from "../../types/chat.ts";
+import type { ProviderUsageSource } from "../../services/provider-usage/usage-source.ts";
+import { AMBIENT_ACCOUNT_KEY } from "../../services/provider-usage/usage-source.ts";
+import { listCodexAccounts, getCodexAccount } from "../../services/codex-account.service.ts";
+import { fetchCodexUsageLive } from "./codex-usage-fetch.ts";
+
+/**
+ * Codex's plug into the shared usage layer.
+ *
+ * All this has to say is which accounts exist and how to read one; the sweep,
+ * the timeout, the cache, and the snapshot persistence come from the layer.
+ * Before it existed, codex had a lazy 60-second memory cache and no sweep at
+ * all, so every read that missed spawned an app-server on the request path.
+ */
+export const codexUsageSource: ProviderUsageSource = {
+  providerId: "codex",
+
+  listAccountIds(): string[] {
+    return listCodexAccounts().map((a) => a.id);
+  },
+
+  async fetch(accountId: string): Promise<UsageInfo> {
+    // No managed accounts configured — read whatever login `~/.codex` holds.
+    if (accountId === AMBIENT_ACCOUNT_KEY) return fetchCodexUsageLive();
+
+    const account = getCodexAccount(accountId);
+    // The account was removed between the sweep listing it and this fetch.
+    // Throwing (rather than returning {}) keeps it out of the store: an empty
+    // object would be persisted as a real reading for an account that is gone.
+    if (!account) throw new Error(`codex account ${accountId} no longer exists`);
+
+    const usage = await fetchCodexUsageLive(account.home);
+    // The rate-limit payload carries the plan name, which the parser puts in
+    // activeAccountLabel; the account's own label is the truthful one.
+    return { ...usage, activeAccountId: account.id, activeAccountLabel: account.label };
+  },
+};

package/src/server/routes/chat.ts

@@ -8,8 +8,9 @@ import { draftService } from "../../services/draft.service.ts";
 import { providerRegistry } from "../../providers/registry.ts";
 import { renameSession as sdkRenameSession } from "@anthropic-ai/claude-agent-sdk";
 import { listSlashItems, searchSlashItems, invalidateCache } from "../../services/slash-items.service.ts";
+import type { SlashItem } from "../../services/slash-discovery/types.ts";
 import { ensureSdkCommands, invalidateSdkCommands } from "../../services/slash-discovery/sdk-commands.ts";
-import { upsertSlashRecent, getSlashRecents, setSessionClearedFrom, listTurnUsage, getSessionAccount } from "../../services/db.service.ts";
+import { upsertSlashRecent, getSlashRecents, setSessionClearedFrom, listTurnUsage, getSessionAccount, getSessionProvider, resolveMigratedSession } from "../../services/db.service.ts";
 import type { TurnUsage } from "../../shared/turn-usage.ts";
 import { getCachedUsage, refreshUsageNow } from "../../services/claude-usage.service.ts";
 import { getSessionLog } from "../../services/session-log.service.ts";
@@ -37,10 +38,14 @@ chatRoutes.get("/slash-items", async (c) => {
   try {
     const projectPath = c.get("projectPath");
     const q = c.req.query("q");
-    // Claude's own built-ins need a live SDK session to enumerate; cached 30 min,
-    // so only the first request per project pays for the CLI spawn.
-    await ensureSdkCommands(projectPath);
-    let items = listSlashItems(projectPath);
+    const sessionId = c.req.query("sessionId") || undefined;
+    // A brand-new tab has no DB row yet, so the client's own view of which
+    // provider it is on wins; the stored value is the fallback for reloads.
+    const providerId = c.req.query("providerId")
+      || (sessionId ? getSessionProvider(sessionId) : null)
+      || undefined;
+
+    let items = await listSlashItemsForProvider(projectPath, providerId, sessionId);
     const recentNames = getSlashRecents(projectPath);
     if (q) items = searchSlashItems(items, q, 20, recentNames);
     return c.json(ok({ items, recentNames }));
@@ -49,6 +54,41 @@ chatRoutes.get("/slash-items", async (c) => {
   }
 });
 
+/**
+ * Slash items a session can actually run.
+ *
+ * A provider that owns its own skill runtime answers for itself, and the
+ * disk-discovered Claude-side list is not merged in: a codex turn cannot
+ * execute a Claude skill, and a Claude turn cannot execute a codex one, so a
+ * combined list would offer entries that quietly do nothing when picked.
+ *
+ * PPM's host-level built-ins ARE kept, because they are intercepted before any
+ * provider runs and therefore work in every tab. Dropping them would have cost
+ * a codex tab `/clear`, `/skills`, and `/version` — commands that do work —
+ * which is a different thing from hiding ones that don't.
+ *
+ * When such a provider reports no skills — app-server failed to spawn, account
+ * not logged in — only the built-ins remain, rather than falling back to the
+ * Claude list; showing runnable-looking Claude entries in a codex tab is the
+ * very confusion this split exists to remove.
+ */
+async function listSlashItemsForProvider(
+  projectPath: string,
+  providerId: string | undefined,
+  sessionId: string | undefined,
+): Promise<SlashItem[]> {
+  const provider = providerId ? providerRegistry.get(providerId) : null;
+  if (provider?.listSkills) {
+    const { codexSkillsToSlashItems } = await import("../../services/slash-discovery/codex-skill-items.ts");
+    const { getHostBuiltinSlashItems } = await import("../../services/slash-discovery/builtin-commands.ts");
+    return [...codexSkillsToSlashItems(await provider.listSkills(sessionId)), ...getHostBuiltinSlashItems()];
+  }
+  // Claude's own built-ins need a live SDK session to enumerate; cached 30 min,
+  // so only the first request per project pays for the CLI spawn.
+  await ensureSdkCommands(projectPath);
+  return listSlashItems(projectPath);
+}
+
 /** DELETE /chat/slash-items/cache — invalidate cached slash items for this project */
 chatRoutes.delete("/slash-items/cache", (c) => {
   try {
@@ -78,9 +118,16 @@ chatRoutes.get("/usage", async (c) => {
   // Non-Claude providers expose their own quota via provider.getUsage().
   const providerId = c.req.query("providerId");
   if (providerId && providerId !== "claude") {
-    const provider = providerRegistry.get(providerId) as { getUsage?: () => Promise<unknown> } | undefined;
+    const provider = providerRegistry.get(providerId);
     if (provider?.getUsage) {
-      try { return c.json(ok(await provider.getUsage())); } catch { return c.json(ok({})); }
+      // `?refresh=1` is the user pressing refresh, so drop the cached value
+      // first — otherwise getUsage answers from cache and the button does
+      // nothing visible. Claude's branch below does the same via a sweep.
+      if (c.req.query("refresh")) {
+        const { invalidateUsage } = await import("../../services/provider-usage/usage-registry.ts");
+        invalidateUsage(providerId);
+      }
+      try { return c.json(ok(await provider.getUsage(c.req.query("session")))); } catch { return c.json(ok({})); }
     }
     return c.json(ok({}));
   }
@@ -270,7 +317,11 @@ chatRoutes.get("/search", async (c) => {
 /** GET /chat/sessions/:id/messages — get message history */
 chatRoutes.get("/sessions/:id/messages", async (c) => {
   try {
-    const id = c.req.param("id");
+    const requestedId = c.req.param("id");
+    // A provider that mints its own session id leaves the id PPM created behind,
+    // owning no transcript. Follow the recorded move so a tab that still holds
+    // the old id reads the conversation instead of an empty list.
+    const id = resolveMigratedSession(requestedId);
     const providerId = c.req.query("providerId") ?? "claude";
     const messages = await chatService.getMessages(providerId, id);
     // Forking re-timestamps the copied prefix (both the Claude SDK and codex
@@ -289,7 +340,14 @@ chatRoutes.get("/sessions/:id/messages", async (c) => {
     }
     // versionMap ships with the history so the `‹ n/m ›` switcher needs no
     // per-message request. Ordinals absent from the map have no edited versions.
-    return c.json(ok({ messages, versionMap: resolveVersionMap(id) }));
+    // Hand back the id that actually owns this transcript so the client can
+    // adopt it — otherwise every future read, and the next turn, still targets
+    // the abandoned one.
+    return c.json(ok({
+      messages,
+      versionMap: resolveVersionMap(id),
+      ...(id !== requestedId ? { canonicalSessionId: id } : {}),
+    }));
   } catch (e) {
     return c.json(err((e as Error).message), 500);
   }

package/src/server/routes/codex-accounts.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { ok, err } from "../../types/api.ts";
 import { listCodexAccounts, removeCodexAccount, getAllCodexUsages, getCodexStrategy, setCodexStrategy, type CodexStrategy } from "../../services/codex-account.service.ts";
-import { addApiKeyAccount, startDeviceLogin, awaitDeviceLogin } from "../../services/codex-account-login.ts";
+import { addApiKeyAccount, startDeviceLogin, getDeviceLoginStatus, cancelDeviceLogin } from "../../services/codex-account-login.ts";
 import { exportCodexEncrypted, importCodexEncrypted } from "../../services/codex-account-portability.ts";
 
 /** Codex multi-account management. Mounted under /api/codex-accounts (auth-guarded). */
@@ -36,10 +36,14 @@ codexAccountsRoutes.post("/device-login", async (c) => {
   catch (e) { return c.json(err((e as Error).message), 400); }
 });
 
-/** Long-poll until the device login completes; persists the account on success. */
-codexAccountsRoutes.post("/device-login/:id/await", async (c) => {
-  try { return c.json(ok(await awaitDeviceLogin(c.req.param("id"))), 201); }
-  catch (e) { return c.json(err((e as Error).message), 400); }
+/** Poll a device login. Answers immediately: holding the connection open for the
+ * whole authorization made a dropped socket look like a failed login. */
+codexAccountsRoutes.get("/device-login/:id/status", (c) => c.json(ok(getDeviceLoginStatus(c.req.param("id")))));
+
+/** Abandon a device login the user closed out of. */
+codexAccountsRoutes.delete("/device-login/:id", (c) => {
+  cancelDeviceLogin(c.req.param("id"));
+  return c.json(ok({ cancelled: true }));
 });
 
 /** Download a password-encrypted backup of codex accounts (auth.json + apiKey creds). */

package/src/server/ws/chat.ts

@@ -3,7 +3,7 @@ import { providerRegistry } from "../../providers/registry.ts";
 import { resolveProjectPath } from "../helpers/resolve-project.ts";
 import { logSessionEvent } from "../../services/session-log.service.ts";
 import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
-import { getSessionTitle, incrementSessionUnread, clearSessionUnread, getSessionModel, setSessionModel, getSessionProvider, getSessionEffort, setSessionEffort, getSessionThinking, setSessionThinking } from "../../services/db.service.ts";
+import { getSessionTitle, incrementSessionUnread, clearSessionUnread, getSessionModel, setSessionModel, getSessionProvider, getSessionEffort, setSessionEffort, getSessionThinking, setSessionThinking, setSessionMigratedTo } from "../../services/db.service.ts";
 import { VALID_EFFORT_VALUES, THINKING_ADAPTIVE, isThinkingEnabled } from "../../providers/claude-agent-sdk-query-options.ts";
 import type { ChatWsClientMessage, SessionPhase } from "../../types/api.ts";
 // File watching and app-wide broadcasts are owned by the global WS (`./global.ts`)
@@ -397,6 +397,40 @@ async function detectImplicitTeam(sessionId: string): Promise<void> {
 }
 
 /** Transition session phase — guards same-phase, broadcasts phase_changed */
+/**
+ * Rewrite a typed `/skill` to the sigil the session's provider recognises, in
+ * place on the parsed message.
+ *
+ * Only providers that own a skill runtime (`listSkills`) are affected, so a
+ * Claude session is left alone entirely. PPM's own built-ins are checked first
+ * and never rewritten: `/clear` and `/version` are handled by PPM regardless of
+ * which provider the tab is on, and must keep their slash to be intercepted.
+ */
+async function rewriteProviderSkillSigil(
+  parsed: { content: string },
+  providerId: string,
+  sessionId: string,
+): Promise<void> {
+  const content = parsed.content.trimStart();
+  if (!content.startsWith("/")) return;
+  const provider = providerRegistry.get(providerId);
+  if (!provider?.listSkills) return;
+
+  const { isPpmHandled } = await import("../../services/slash-discovery/index.ts");
+  const name = content.match(/^\/(\S+)/)?.[1];
+  if (!name || isPpmHandled(name)) return;
+
+  try {
+    const { applySkillSigil } = await import("../../services/slash-discovery/provider-skill-sigil.ts");
+    const skills = await provider.listSkills(sessionId);
+    const rewritten = applySkillSigil(content, new Set(skills.map((s) => s.name)), "$");
+    if (rewritten !== content) parsed.content = rewritten;
+  } catch {
+    // Listing failed (app-server down, account not logged in). Send what the
+    // user typed rather than dropping their message.
+  }
+}
+
 function setPhase(sessionId: string, phase: SessionPhase, elapsed?: number): void {
   const entry = activeSessions.get(sessionId);
   if (!entry || entry.phase === phase) return;
@@ -802,6 +836,10 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         const newId = ev.newSessionId as string;
         if (newId && newId !== sessionId) {
           console.log(`[chat] session_migrated: ${sessionId} → ${newId}`);
+          // Persist the link before re-keying. A tab that opened under the old
+          // id keeps it in its own storage, so without this the conversation
+          // becomes unreachable from that tab the moment the turn ends.
+          setSessionMigratedTo(sessionId, newId);
           // Stop spies tagged with old session ID before re-keying
           bashOutputSpy.stopAllForSession(sessionId);
           nestedSubagentSpy.stopAllForSession(sessionId);
@@ -1138,6 +1176,13 @@ export const chatWebSocket = {
         if (canonical !== typedContent) parsed.content = canonical;
       }
 
+      // Providers with their own skill runtime may not use a leading slash.
+      // Codex resolves a skill from a `$name` mention in the prompt; sent as
+      // `/imagegen` it is inert prose, so the picked skill would silently not
+      // run. Rewritten before the echo for the same reason as the alias above:
+      // other devices and the stored transcript must show what actually ran.
+      await rewriteProviderSkillSigil(parsed, providerId, sessionId);
+
       // Echo the user message to OTHER connected clients (second device/tab).
       // The sender renders it optimistically; without this echo a live-connected
       // second device only sees the assistant stream for this turn.

package/src/services/claude-usage-source.ts

@@ -0,0 +1,40 @@
+import type { UsageInfo } from "../types/chat.ts";
+import type { ProviderUsageSource } from "./provider-usage/usage-source.ts";
+import { AMBIENT_ACCOUNT_KEY } from "./provider-usage/usage-source.ts";
+import { accountService } from "./account.service.ts";
+import {
+  fetchClaudeAccountUsage,
+  fetchLegacyClaudeUsage,
+  shouldSkipClaudeAccount,
+} from "./claude-usage.service.ts";
+
+/**
+ * Claude's plug into the shared usage layer.
+ *
+ * Everything Claude-specific stays in `claude-usage.service`: OAuth token
+ * refresh, the post-429 cooldown, the Keychain fallback for installs that never
+ * added an account. What this adapter removes is the second copy of the generic
+ * machinery — Claude used to own its own poll timer, stagger, in-flight dedup,
+ * and persistence, all of which now come from the layer and are shared with
+ * codex.
+ */
+export const claudeUsageSource: ProviderUsageSource = {
+  providerId: "claude",
+
+  listAccountIds(): string[] {
+    // Empty means no account store, and the layer falls back to the ambient
+    // login — which is exactly the legacy single-login install.
+    return accountService.list().map((a) => a.id);
+  },
+
+  shouldSkip(accountId: string): Promise<boolean> {
+    // The ambient login has no account row to consult, so nothing to skip on.
+    if (accountId === AMBIENT_ACCOUNT_KEY) return Promise.resolve(false);
+    return shouldSkipClaudeAccount(accountId);
+  },
+
+  async fetch(accountId: string): Promise<UsageInfo> {
+    if (accountId === AMBIENT_ACCOUNT_KEY) return fetchLegacyClaudeUsage();
+    return fetchClaudeAccountUsage(accountId);
+  },
+};