@hienlh/ppm 0.18.13 → 0.18.15

package/src/services/subagent-transcript-merger.ts

@@ -5,11 +5,13 @@
  * session JSONL (no isSidechain lines, no parent_tool_use_id). Instead each
  * agent gets its own transcript at:
  *   ~/.claude/projects/<slug>/<sessionId>/subagents/agent-<id>.jsonl
- * with a sibling agent-<id>.meta.json carrying the spawning Agent tool_use id.
+ * with a sibling agent-<id>.meta.json carrying the spawning Agent tool_use id
+ * (session-spawned agents) or the spawning agent's id (nested agents).
  *
  * Without merging these, a reloaded session shows bare Agent cards and the
- * live-streamed children are lost. This module reads the meta files, parses
- * each agent transcript, and attaches its events as the card's children.
+ * live-streamed children are lost. This module groups the transcripts under
+ * their session-level card, parses each one, and attaches the events — every
+ * nesting level flattened into one time-ordered list — as the card's children.
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
@@ -17,18 +19,20 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import type { ChatEvent } from "../types/chat.ts";
 import { parseSessionMessage } from "./jsonl-transcript-parser.ts";
+import { groupSubagentsByCard } from "./team-member-activity/subagent-transcript-index.ts";
 
 /**
  * Locate the per-session directory (…/projects/<slug>/<sessionId>) that holds
- * subagents/. The SDK encodes the cwd by replacing separators + drive colon
- * with "-"; when that drifts (drive-letter case), fall back to scanning
- * project dirs for the session's main JSONL.
+ * subagents/. The SDK encodes the cwd by replacing separators, drive colon
+ * and dots with "-" (`…\ppm\.claude\worktrees\x` → `…-ppm--claude-worktrees-x`);
+ * when that drifts (drive-letter case), fall back to scanning project dirs for
+ * the session's main JSONL.
  */
 export function resolveSessionDir(sessionId: string, projectPath: string | null | undefined): string | null {
   const home = homedir();
   const projectsRoot = join(home, ".claude", "projects");
   if (projectPath) {
-    const encoded = projectPath.replace(/[/\\:]/g, "-");
+    const encoded = projectPath.replace(/[/\\:.]/g, "-");
     const dir = join(projectsRoot, encoded);
     if (existsSync(join(dir, `${sessionId}.jsonl`))) return join(dir, sessionId);
   }
@@ -53,92 +57,105 @@ interface MessageLike {
 const MAX_CHILDREN_PER_AGENT = 2000;
 const MAX_CHILD_OUTPUT_CHARS = 50_000;
 
-/** Map of Agent-card toolUseId → agent transcript path, from subagents/*.meta.json */
-function indexAgentTranscripts(subagentsDir: string): Map<string, string> {
-  const map = new Map<string, string>();
-  let entries: string[];
-  try {
-    entries = readdirSync(subagentsDir);
-  } catch {
-    return map;
-  }
-  for (const name of entries) {
-    if (!name.endsWith(".meta.json")) continue;
-    try {
-      const meta = JSON.parse(readFileSync(join(subagentsDir, name), "utf8"));
-      const toolUseId = meta?.toolUseId as string | undefined;
-      if (!toolUseId) continue;
-      const transcript = join(subagentsDir, name.replace(/\.meta\.json$/, ".jsonl"));
-      if (existsSync(transcript)) map.set(toolUseId, transcript);
-    } catch {
-      /* unreadable meta — skip this agent */
-    }
-  }
-  return map;
+/** One child event plus the transcript record time it came from (epoch ms). */
+export interface TimedChatEvent {
+  ts: number;
+  ev: ChatEvent;
 }
 
-/** Parse one agent transcript into a flat children event list (stream order). */
-export function parseAgentTranscript(filePath: string): ChatEvent[] {
-  const children: ChatEvent[] = [];
+/**
+ * Incremental parser for one agent transcript. Feed it JSONL lines in file
+ * order (whole file at once, or a live tail's new lines) and it returns the
+ * child events those lines carry, keeping the skip/limit state across calls.
+ */
+export function createAgentTranscriptLineParser() {
+  let isFirstUser = true;
+  let emitted = 0;
+  let lastTs = 0;
+  return {
+    feed(line: string): TimedChatEvent[] {
+      const out: TimedChatEvent[] = [];
+      const trimmed = line.trim();
+      if (!trimmed || emitted >= MAX_CHILDREN_PER_AGENT) return out;
+      let entry: any;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        return out;
+      }
+      if (entry.type !== "user" && entry.type !== "assistant") return out;
+      if (!entry.message) return out;
+      // The first user record is the agent's spawn prompt — the live stream
+      // never showed it as a child, so skip it to match the streaming view.
+      if (entry.type === "user" && isFirstUser) {
+        isFirstUser = false;
+        const content = entry.message?.content;
+        const hasToolResult = Array.isArray(content) && content.some((b: any) => b?.type === "tool_result");
+        if (!hasToolResult) return out;
+      }
+      // Records without a timestamp inherit the previous one so file order holds.
+      const parsedTs = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+      if (!Number.isNaN(parsedTs)) lastTs = parsedTs;
+      const parsed = parseSessionMessage(entry);
+      for (const ev of parsed.events ?? []) {
+        if (emitted >= MAX_CHILDREN_PER_AGENT) break;
+        // Keep single events from ballooning the history payload (agent files
+        // can carry multi-MB tool outputs the live stream also showed in full,
+        // but 24 agents × full outputs breaks mobile reloads).
+        if (ev.type === "tool_result" && typeof ev.output === "string" && ev.output.length > MAX_CHILD_OUTPUT_CHARS) {
+          ev.output = ev.output.slice(0, MAX_CHILD_OUTPUT_CHARS) + "\n… [truncated]";
+        }
+        out.push({ ts: lastTs, ev });
+        emitted++;
+      }
+      return out;
+    },
+  };
+}
+
+/** Parse one whole agent transcript into timed child events (file order). */
+export function parseAgentTranscriptTimed(filePath: string): TimedChatEvent[] {
   let text: string;
   try {
     text = readFileSync(filePath, "utf8");
   } catch {
-    return children;
-  }
-  let isFirstUser = true;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let entry: any;
-    try {
-      entry = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (entry.type !== "user" && entry.type !== "assistant") continue;
-    if (!entry.message) continue;
-    if (children.length >= MAX_CHILDREN_PER_AGENT) break;
-    // The first user record is the agent's spawn prompt — the live stream
-    // never showed it as a child, so skip it to match the streaming view.
-    if (entry.type === "user" && isFirstUser) {
-      isFirstUser = false;
-      const content = entry.message?.content;
-      const hasToolResult = Array.isArray(content) && content.some((b: any) => b?.type === "tool_result");
-      if (!hasToolResult) continue;
-    }
-    const parsed = parseSessionMessage(entry);
-    for (const ev of parsed.events ?? []) {
-      // Keep single events from ballooning the history payload (agent files
-      // can carry multi-MB tool outputs the live stream also showed in full,
-      // but 24 agents × full outputs breaks mobile reloads).
-      if (ev.type === "tool_result" && typeof ev.output === "string" && ev.output.length > MAX_CHILD_OUTPUT_CHARS) {
-        ev.output = ev.output.slice(0, MAX_CHILD_OUTPUT_CHARS) + "\n… [truncated]";
-      }
-      children.push(ev);
-    }
+    return [];
   }
-  return children;
+  const parser = createAgentTranscriptLineParser();
+  const out: TimedChatEvent[] = [];
+  for (const line of text.split("\n")) out.push(...parser.feed(line));
+  return out;
+}
+
+/** Parse one agent transcript into a flat children event list (stream order). */
+export function parseAgentTranscript(filePath: string): ChatEvent[] {
+  return parseAgentTranscriptTimed(filePath).map((t) => t.ev);
 }
 
 /**
  * Attach subagent transcript events as children of their Agent/Task cards.
  * `sessionDir` is the per-session directory next to the main JSONL
- * (…/projects/<slug>/<sessionId>). Existing children are replaced — the disk
- * transcript is the complete record, while live-collected children may be a
- * partial overlap. Mutates messages in-place.
+ * (…/projects/<slug>/<sessionId>). A card's group — the agent it spawned plus
+ * any agents that one spawned in turn — is merged into one list ordered by
+ * record time, so a nested worker's steps read where they happened rather
+ * than after the parent agent's conclusion. Existing children are replaced —
+ * the disk transcripts are the complete record, while live-collected children
+ * may be a partial overlap. Mutates messages in-place.
  */
 export function mergeSubagentChildren(sessionDir: string, messages: MessageLike[]): void {
-  const index = indexAgentTranscripts(join(sessionDir, "subagents"));
-  if (index.size === 0) return;
+  const groups = groupSubagentsByCard(join(sessionDir, "subagents"));
+  if (groups.size === 0) return;
 
   for (const msg of messages) {
     for (const ev of msg.events ?? []) {
       if (ev.type !== "tool_use" || (ev.tool !== "Agent" && ev.tool !== "Task") || !ev.toolUseId) continue;
-      const transcript = index.get(ev.toolUseId);
-      if (!transcript) continue;
-      const children = parseAgentTranscript(transcript);
-      if (children.length > 0) ev.children = children;
+      const group = groups.get(ev.toolUseId);
+      if (!group) continue;
+      const timed: TimedChatEvent[] = [];
+      for (const agent of group) timed.push(...parseAgentTranscriptTimed(agent.transcriptPath));
+      // Stable sort: same-timestamp events keep transcript order.
+      timed.sort((a, b) => a.ts - b.ts);
+      if (timed.length > 0) ev.children = timed.map((t) => t.ev);
     }
   }
 }

package/src/services/subprocess-retention.ts

@@ -13,13 +13,36 @@
  */
 
 /**
- * Anthropic's default prompt-cache lifetime. A prefix not re-sent within this window has to
- * be written to the cache again, so a subprocess older than this is worth nothing.
+ * Anthropic's prompt-cache lifetime, per auth mode. From the SDK's own typings: "1 hour on a
+ * Claude subscription within its usage limits, 5 minutes on an API key, Bedrock, Vertex or
+ * Foundry."
  *
- * Named here rather than inlined because the retention window is *derived* from it — the two
- * were previously equal by coincidence, which read as if the teardown delay were arbitrary.
+ * Both are named here because the retention window is *derived* from whichever applies — the
+ * delay was previously equal to the TTL by coincidence, which read as arbitrary.
+ *
+ * Which one a session gets is not a constant: PPM supports settings `api_key` and a custom
+ * `base_url` as first-class options, and "within its usage limits" excludes exactly the
+ * accounts the rotation exists for. Holding a subprocess for an hour on an API-key install
+ * guards a cache that died at minute five, at ~350MB a session. The provider decides; these
+ * are the two values it picks between.
+ */
+export const SUBSCRIPTION_PROMPT_CACHE_TTL_MS = 60 * 60_000;
+export const API_KEY_PROMPT_CACHE_TTL_MS = 5 * 60_000;
+
+/** The longer of the two — what a timer that must outlast any cache window has to clear. */
+export const PROMPT_CACHE_TTL_MS = SUBSCRIPTION_PROMPT_CACHE_TTL_MS;
+
+/**
+ * What a provider that does not state a window gets.
+ *
+ * The short one, deliberately. `promptCacheTtlMs` is optional on the provider interface, so
+ * "no opinion" and "an hour" would otherwise be the same answer — and the providers without
+ * an opinion are exactly the ones with no Anthropic prompt cache to protect. Codex reaches
+ * this path today: it implements `hasStreamingSession` but not `promptCacheTtlMs`, so an
+ * hour here would hold ~350MB per abandoned session guarding a cache it never had. A
+ * provider that benefits from the long window says so.
  */
-export const PROMPT_CACHE_TTL_MS = 5 * 60_000;
+const UNDECLARED_PROMPT_CACHE_TTL_MS = API_KEY_PROMPT_CACHE_TTL_MS;
 
 /**
  * Milliseconds until a session's prompt cache lapses.
@@ -31,7 +54,7 @@ export const PROMPT_CACHE_TTL_MS = 5 * 60_000;
 export function cacheReleaseDelayMs(
   lastTurnEndedAt: number | undefined,
   now: number,
-  ttlMs: number = PROMPT_CACHE_TTL_MS,
+  ttlMs: number = UNDECLARED_PROMPT_CACHE_TTL_MS,
 ): number {
   // No completed turn means nothing has been cached, so there is nothing to protect.
   if (lastTurnEndedAt == null) return 0;

package/src/services/supervisor.ts

@@ -52,6 +52,9 @@ const TUNNEL_URL_REGEX = /https:\/\/(?!api\.)[a-z0-9-]+\.trycloudflare\.com/;
 const NAMED_TUNNEL_READY_REGEX = /Registered tunnel connection/;
 const UPGRADE_CHECK_INTERVAL_MS = 900_000;  // 15min
 const UPGRADE_SKIP_INITIAL_MS = 300_000;    // 5min delay before first check
+const DB_BACKUP_INTERVAL_MS = 3_600_000;    // 1h — the recovery-point target
+const DB_BACKUP_START_DELAY_MS = 30_000;    // let the server settle before the first snapshot
+const DB_BACKUP_STALE_WARN_MS = 21_600_000; // 6h — snapshots stopped happening
 const SELF_REPLACE_TIMEOUT_MS = 30_000;     // 30s to wait for new supervisor
 const EDGE_PROBE_INTERVAL_MS = 10_000;      // the public port is dark while the edge is down — check often
 const SERVER_PORT_MIRROR_TIMEOUT_MS = 30_000; // how long to wait for the server to publish its port
@@ -127,6 +130,7 @@ let healthTimer: ReturnType<typeof setInterval> | null = null;
 let tunnelProbeTimer: ReturnType<typeof setInterval> | null = null;
 let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
 let upgradeCheckTimer: ReturnType<typeof setInterval> | null = null;
+let dbBackupTimer: ReturnType<typeof setInterval> | null = null;
 let upgradeDelayTimer: ReturnType<typeof setTimeout> | null = null;
 let cloudMonitorTimer: ReturnType<typeof setInterval> | null = null;
 let descendantSnapshotTimer: ReturnType<typeof setInterval> | null = null; // win32 only
@@ -936,6 +940,41 @@ export async function spawnTunnel(port: number, generation: number = ++tunnelGen
   return retryTunnelAfterFailure(generation);
 }
 
+// ─── Config-database snapshots ─────────────────────────────────────────
+let dbBackupDelayTimer: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * Take one verified snapshot of the config database, then report whether
+ * snapshots are keeping up.
+ *
+ * Failures are logged and swallowed: a backup problem must never take the
+ * server down. The staleness warning exists because a silently-failing backup
+ * is worse than no backup — it is the state where recovery is believed to be
+ * available and is not.
+ */
+async function runDbBackupTick(reason: "hourly" | "start"): Promise<void> {
+  if (shuttingDown) return;
+  try {
+    const { backupDb } = await import("./db-backup/db-backup.service.ts");
+    const result = await backupDb(reason);
+    const mb = (result.bytes / 1_048_576).toFixed(1);
+    const prunedNote = result.pruned.length ? `, pruned ${result.pruned.length}` : "";
+    log("INFO", `DB snapshot (${reason}): ${result.path} ${mb}MB in ${result.ms}ms${prunedNote}`);
+  } catch (e: any) {
+    log("ERROR", `DB snapshot (${reason}) failed: ${e?.message ?? e}`);
+  }
+
+  try {
+    const { newestBackupAgeMs } = await import("./db-backup/db-backup.service.ts");
+    const age = await newestBackupAgeMs();
+    if (age === null) {
+      log("WARN", "DB snapshot: no backups exist yet — the database is currently unrecoverable");
+    } else if (age > DB_BACKUP_STALE_WARN_MS) {
+      log("WARN", `DB snapshot: newest backup is ${Math.round(age / 3_600_000)}h old — recovery point is degraded`);
+    }
+  } catch { /* staleness reporting is advisory only */ }
+}
+
 // ─── Health checks ─────────────────────────────────────────────────────
 function startServerHealthCheck() {
   healthTimer = setInterval(async () => {
@@ -1314,6 +1353,8 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       if (upgradeCheckTimer) clearInterval(upgradeCheckTimer);
       if (upgradeDelayTimer) clearTimeout(upgradeDelayTimer);
+      if (dbBackupTimer) clearInterval(dbBackupTimer);
+      if (dbBackupDelayTimer) clearTimeout(dbBackupDelayTimer);
       if (cloudMonitorTimer) clearInterval(cloudMonitorTimer);
       // Disconnect Cloud WS so new supervisor can reconnect cleanly
       try { const { disconnect } = await import("./cloud-ws.service.ts"); disconnect(); } catch {}
@@ -1398,6 +1439,8 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
           if (heartbeatTimer) clearInterval(heartbeatTimer);
           if (upgradeCheckTimer) clearInterval(upgradeCheckTimer);
           if (upgradeDelayTimer) clearTimeout(upgradeDelayTimer);
+          if (dbBackupTimer) clearInterval(dbBackupTimer);
+          if (dbBackupDelayTimer) clearTimeout(dbBackupDelayTimer);
           process.exit(0);
         }
       } catch {}
@@ -1680,6 +1723,8 @@ export function shutdown() {
   if (heartbeatTimer) clearInterval(heartbeatTimer);
   if (upgradeCheckTimer) clearInterval(upgradeCheckTimer);
   if (upgradeDelayTimer) clearTimeout(upgradeDelayTimer);
+  if (dbBackupTimer) clearInterval(dbBackupTimer);
+  if (dbBackupDelayTimer) clearTimeout(dbBackupDelayTimer);
   if (cloudMonitorTimer) clearInterval(cloudMonitorTimer);
   if (descendantSnapshotTimer) clearInterval(descendantSnapshotTimer);
 
@@ -1962,6 +2007,19 @@ export async function runSupervisor(opts: {
     }
   }, RESUME_TICK_MS);
 
+  // Snapshot the config database on a schedule. The supervisor is the only
+  // always-on process, so this is the one place a periodic snapshot survives
+  // both server restarts and crash-backoff windows.
+  //
+  // The start-up snapshot is not redundant with the hourly one: a machine that
+  // is only powered on for short sessions, or a supervisor that sat paused
+  // after exhausting its restart budget, would otherwise take no snapshot at
+  // all for as long as that lasted.
+  dbBackupDelayTimer = setTimeout(() => {
+    void runDbBackupTick("start");
+    dbBackupTimer = setInterval(() => void runDbBackupTick("hourly"), DB_BACKUP_INTERVAL_MS);
+  }, DB_BACKUP_START_DELAY_MS);
+
   // Start upgrade check timer (5min initial delay, then every 15min)
   upgradeDelayTimer = setTimeout(() => {
     checkAvailableVersion();

package/src/services/team-member-activity/subagent-transcript-index.ts

@@ -26,6 +26,15 @@ export interface SubagentTranscriptEntry {
   model?: string;
   /** tool_use id of the spawning Agent call — links back to the chat card. */
   toolUseId?: string;
+  /** Raw id from the `agent-<id>` file stem — the form `parentAgentId` uses. */
+  agentId: string;
+  /**
+   * agentId of the agent that spawned this one. Set on nested agents (a
+   * subagent that itself called Agent/Skill); those metas carry no toolUseId
+   * because the spawning tool_use lives in the parent agent's transcript, not
+   * the session's.
+   */
+  parentAgentId?: string;
   /** Absolute path of the agent's JSONL transcript. */
   transcriptPath: string;
   /** Transcript size in bytes — the cheap "how much work" signal. */
@@ -69,6 +78,8 @@ export function listSubagentTranscripts(subagentsDir: string): SubagentTranscrip
       description: typeof meta.description === "string" ? meta.description : undefined,
       model: typeof meta.model === "string" ? meta.model : undefined,
       toolUseId: typeof meta.toolUseId === "string" ? meta.toolUseId : undefined,
+      agentId: file.replace(/^agent-/, "").replace(/\.meta\.json$/, ""),
+      parentAgentId: typeof meta.parentAgentId === "string" ? meta.parentAgentId : undefined,
       transcriptPath,
       sizeBytes,
       modifiedAt,
@@ -77,6 +88,51 @@ export function listSubagentTranscripts(subagentsDir: string): SubagentTranscrip
   return out;
 }
 
+/**
+ * Group every transcript under the session-level Agent card it belongs to.
+ *
+ * The CLI only stamps `toolUseId` on agents the session itself spawned. A
+ * nested agent (spawned by another agent, e.g. a reviewer running a skill that
+ * forks its own worker) has only `parentAgentId`, and the SDK streams none of
+ * its activity — so the card's transcript group is the only place its work can
+ * surface. Walk each chain up to the root and key by that root's toolUseId.
+ * Entries are ordered root first, then descendants by depth.
+ */
+export function groupSubagentsByCard(subagentsDir: string): Map<string, SubagentTranscriptEntry[]> {
+  const entries = listSubagentTranscripts(subagentsDir);
+  const byId = new Map(entries.map((e) => [e.agentId, e]));
+  const rootOf = (entry: SubagentTranscriptEntry): { root: SubagentTranscriptEntry; depth: number } | null => {
+    let cur = entry;
+    let depth = 0;
+    const seen = new Set<string>();
+    while (cur.parentAgentId) {
+      if (seen.has(cur.agentId)) return null; // cyclic metas — corrupt, skip
+      seen.add(cur.agentId);
+      const parent = byId.get(cur.parentAgentId);
+      if (!parent) return null; // parent meta missing — cannot attach anywhere
+      cur = parent;
+      depth++;
+    }
+    return cur.toolUseId ? { root: cur, depth } : null;
+  };
+
+  const groups = new Map<string, Array<{ entry: SubagentTranscriptEntry; depth: number }>>();
+  for (const entry of entries) {
+    const resolved = rootOf(entry);
+    if (!resolved) continue;
+    const key = resolved.root.toolUseId!;
+    const list = groups.get(key) ?? [];
+    list.push({ entry, depth: resolved.depth });
+    groups.set(key, list);
+  }
+  const out = new Map<string, SubagentTranscriptEntry[]>();
+  for (const [key, list] of groups) {
+    list.sort((a, b) => a.depth - b.depth);
+    out.set(key, list.map((l) => l.entry));
+  }
+  return out;
+}
+
 /**
  * Newest transcript per teammate name.
  *

package/src/types/chat.ts

@@ -49,6 +49,8 @@ export interface AIProvider {
   getUsage?(): Promise<UsageInfo>;
   /** True when a live streaming subprocess exists for this session */
   hasStreamingSession?(sessionId: string): boolean;
+  /** Prompt-cache lifetime for this session, in ms — how long holding its subprocess pays. */
+  promptCacheTtlMs?(sessionId: string): number;
 }
 
 export interface ModelOption {

package/src/web/app.tsx

@@ -48,6 +48,9 @@ const MobileExplorerSheet = lazy(() =>
 const TeamMemberSheet = lazy(() =>
   import("@/components/chat/team-member-sheet").then((m) => ({ default: m.TeamMemberSheet })),
 );
+const RemoteDesktopMobileSheet = lazy(() =>
+  import("@/components/remote-desktop/remote-desktop-mobile-sheet").then((m) => ({ default: m.RemoteDesktopMobileSheet })),
+);
 
 type AuthState = "checking" | "authenticated" | "unauthenticated";
 
@@ -357,6 +360,11 @@ export function App() {
           <TeamMemberSheet />
         </Suspense>
 
+        {/* Mobile full-screen remote-desktop viewer — same reason as TeamMemberSheet above */}
+        <Suspense fallback={null}>
+          <RemoteDesktopMobileSheet />
+        </Suspense>
+
         {/* Global bug report popup */}
         <BugReportPopup />
 

package/src/web/components/chat/account-dialogs.tsx

@@ -70,9 +70,14 @@ export function AddAccountDialog({ open, onOpenChange, onSuccess }: AddAccountDi
     try {
       let code = oauthCode.trim();
       if (code.includes("#")) code = code.split("#")[0] ?? code;
-      await exchangeOAuthCode(code, oauthState);
+      const acc = await exchangeOAuthCode(code, oauthState);
       handleClose();
-      onSuccess("Account connected via OAuth!");
+      // Signing in again on an account this machine parked carries the token in but
+      // deliberately leaves it out of the rotation. A flat success over a toggle that is
+      // still off reads as a bug, and this is the only place the user finds out otherwise.
+      onSuccess(acc?.status === "disabled"
+        ? "Signed in. This account is still disabled — enable it to use it."
+        : "Account connected via OAuth!");
     } catch (e) {
       setAddError((e as Error).message);
     }
@@ -84,9 +89,11 @@ export function AddAccountDialog({ open, onOpenChange, onSuccess }: AddAccountDi
     setAdding(true);
     setAddError(null);
     try {
-      await addAccount({ apiKey: newToken.trim(), label: newLabel.trim() || undefined });
+      const acc = await addAccount({ apiKey: newToken.trim(), label: newLabel.trim() || undefined });
       handleClose();
-      onSuccess("Account added!");
+      onSuccess(acc?.status === "disabled"
+        ? "Token updated. This account is still disabled — enable it to use it."
+        : "Account added!");
     } catch (e) {
       setAddError((e as Error).message);
     }

package/src/web/components/chat/question-card.tsx

@@ -90,7 +90,11 @@ function useQuestionKeyboard(config: {
   useEffect(() => {
     if (!config.enabled) return;
     const handleKeyDown = (e: KeyboardEvent) => {
-      const isTyping = document.activeElement === config.customInputRef.current;
+      // Resolve focus from the input's OWN document: this card can be rendered inside a
+      // picture-in-picture window, and the module-global `document` is always the main one —
+      // there the input is never active, so every printable key would be treated as a shortcut.
+      const input = config.customInputRef.current;
+      const isTyping = !!input && input.ownerDocument.activeElement === input;
 
       // Number keys 1-9
       if (!isTyping && e.key >= "1" && e.key <= "9") {
@@ -132,7 +136,10 @@ function useQuestionKeyboard(config: {
     if (el) {
       el.addEventListener("keydown", handleKeyDown);
       el.setAttribute("tabindex", "0");
-      if (!el.contains(document.activeElement)) el.focus();
+      // Same reason: asking the main document whether focus is already inside the card answers
+      // "no" for a card living in another document, and this effect re-runs on every render —
+      // which would yank focus out of the custom input after each keystroke.
+      if (!el.contains(el.ownerDocument.activeElement)) el.focus();
     }
     return () => { el?.removeEventListener("keydown", handleKeyDown); };
   }, [config, focusedOption]);

package/src/web/components/chat/usage-badge.tsx

@@ -154,11 +154,12 @@ function formatLastUpdated(ts: number | null | undefined): string | null {
   return `${days}d ago`;
 }
 
-function AccountUsageCard({ entry, isActive, accountInfo, onToggle, onDelete, onExport, onViewProfile, flash, fullscreen }: {
+function AccountUsageCard({ entry, isActive, accountInfo, onToggle, toggling, onDelete, onExport, onViewProfile, flash, fullscreen }: {
   entry: AccountUsageEntry;
   isActive: boolean;
   accountInfo?: AccountInfo;
   onToggle?: (id: string, status: string) => void;
+  toggling?: boolean;
   onDelete?: (id: string, display: string) => void;
   onExport?: (id: string) => void;
   onViewProfile?: (profile: OAuthProfileData, accountId: string) => void;
@@ -207,7 +208,7 @@ function AccountUsageCard({ entry, isActive, accountInfo, onToggle, onDelete, on
             <Switch
               checked={status !== "disabled"}
               onCheckedChange={() => onToggle(entry.accountId, status)}
-              disabled={status === "cooldown"}
+              disabled={toggling || status === "cooldown"}
               className="scale-[0.6] cursor-pointer"
             />
           )}
@@ -269,6 +270,7 @@ export function UsageDetailPanel({ usage, visible, onClose, onReload, loading, l
   const [exportPreselect, setExportPreselect] = useState<string | null>(null);
   const [isFullscreen, setIsFullscreen] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
+  const [togglingId, setTogglingId] = useState<string | null>(null);
   const msgTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
   const prevUsagesRef = useRef<AccountUsageEntry[]>([]);
 
@@ -345,7 +347,18 @@ export function UsageDetailPanel({ usage, visible, onClose, onReload, loading, l
   const fsRows = Math.ceil(fsCount / fsCols);
 
   async function handleToggle(id: string, status: string) {
-    await patchAccount(id, { status: status === "disabled" ? "active" : "disabled" });
+    // Enabling a parked account proves its token server-side first, which is a network
+    // round trip that can come back 400 — and patchAccount throws on that. Without the
+    // catch the message the server takes care to write reaches nobody: unhandled
+    // rejection, no toast, no reload, and the Switch silently snaps back. The pending
+    // flag is because that round trip can take most of a minute in the worst case.
+    setTogglingId(id);
+    try {
+      await patchAccount(id, { status: status === "disabled" ? "active" : "disabled" });
+    } catch (e) {
+      showMessage((e as Error).message);
+    }
+    setTogglingId(null);
     loadAll();
     onReload?.();
   }
@@ -440,6 +453,7 @@ export function UsageDetailPanel({ usage, visible, onClose, onReload, loading, l
                 isActive={entry.accountId === (activeAccountId ?? usage.activeAccountId)}
                 accountInfo={accountMap.get(entry.accountId)}
                 onToggle={handleToggle}
+                toggling={togglingId === entry.accountId}
                 onDelete={(id, display) => setDeleteTarget({ id, display })}
                 onExport={(id) => { setExportPreselect(id); setShowExportDialog(true); }}
                 onViewProfile={(profile, accountId) => setProfileView({ profile, accountId })}

package/src/web/components/floating-window/floating-window.tsx

@@ -19,6 +19,7 @@ import { PortalContainerProvider } from "@/components/ui/portal-container-contex
 import { TITLEBAR_HEIGHT } from "./window-chrome-contract";
 import { useWindowBodyElement } from "./use-window-body-element";
 import { WindowPipPlaceholder } from "./window-pip-placeholder";
+import { isPipOnlyWindow } from "./window-pip-registry";
 import { WindowSkinChrome } from "./window-skin-chrome";
 import { windowZIndex, type Bounds, type Rect } from "./window-geometry";
 import { useWindowStore, type WindowRuntimeState } from "./window-store";
@@ -120,6 +121,8 @@ export function FloatingWindow({
     movable: !maximized,
   });
 
+  const hiddenHost = Boolean(pip) && isPipOnlyWindow(win.id);
+
   return (
     <div
       ref={rootRef}
@@ -135,6 +138,10 @@ export function FloatingWindow({
         focused ? "shadow-2xl shadow-black/40" : "shadow-lg shadow-black/20",
         // Transitions are for maximize/restore only; during a gesture they would lag the pointer.
         gesturing ? "transition-none" : "transition-[transform,width,height] duration-150 motion-reduce:transition-none",
+        // A window opened only to carry a tab into PiP is never shown: the user asked for a
+        // PiP, not a window. `hidden` and not an unmount — the body must stay connected, or
+        // the PiP host has nowhere to put the tab back.
+        hiddenHost && "hidden",
       )}
     >
       <WindowSkinChrome
@@ -158,7 +165,7 @@ export function FloatingWindow({
         onClose={close}
       />
 
-      {pip && <WindowPipPlaceholder pip={pip} minimized={minimized} />}
+      {pip && !hiddenHost && <WindowPipPlaceholder pip={pip} minimized={minimized} />}
 
       {!maximized && !minimized && (
         <WindowResizeHandles bind={(handle) => bindResize(handle) as Record<string, unknown>} />