@hienlh/ppm 0.23.21 → 0.23.23

package/src/providers/claude-agent-sdk-query-options.ts

@@ -15,9 +15,20 @@ import {
 } from "../services/tab-tools-mcp/tab-tools-mcp-tool.ts";
 import { TAB_TOOLS } from "../shared/ppm-tools.ts";
 import { CLAUDE_DB_TOOLS_MCP_SERVER, DB_TOOLS, DB_TOOLS_TIMEOUT_MS, type DbToolsMcpAccess } from "../services/db-ai-tools/db-ai-tools-tool.ts";
+import { EFFORT_LEVELS, type EffortLevel } from "../shared/effort-status.ts";
 
-export const VALID_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max"] as const;
-export type EffortValue = (typeof VALID_EFFORT_VALUES)[number];
+export const VALID_EFFORT_VALUES = EFFORT_LEVELS;
+export type EffortValue = EffortLevel;
+
+export type ClaudeSettingSource = "user" | "project" | "local";
+
+/**
+ * The settings files a chat's CLI loads. `local` stays out: a project's
+ * `.claude/settings.local.json` can deny tools and set `env` (an `ANTHROPIC_API_KEY` there moves
+ * the chat onto another account), and the empty `settings` PPM passes cancels neither. The
+ * project's own `.claude/settings.json` is loaded and can do the same; only the local file is out.
+ */
+export const CLAUDE_SETTING_SOURCES: readonly ClaudeSettingSource[] = ["user", "project"];
 
 /**
  * Thinking is a tri-state carried as a nullable integer through config, the DB and

package/src/providers/claude-agent-sdk.ts

@@ -7,7 +7,7 @@ import {
   getSessionInfo as sdkGetSessionInfo,
   getSessionMessages,
 } from "@anthropic-ai/claude-agent-sdk";
-import { allowedToolsFor, buildModelQueryOptions, buildSystemPromptOption, buildToolHooks, CLAUDE_DB_TOOLS, CLAUDE_TAB_TOOLS, dbToolsMcpServers, designMcpServers, fileWriteTarget, preToolUseDecision, READ_ONLY_TOOLS, shellHookCall, tabToolsMcpServers, withSessionTokenMasked } from "./claude-agent-sdk-query-options.ts";
+import { allowedToolsFor, buildModelQueryOptions, CLAUDE_SETTING_SOURCES, buildSystemPromptOption, buildToolHooks, CLAUDE_DB_TOOLS, CLAUDE_TAB_TOOLS, dbToolsMcpServers, designMcpServers, fileWriteTarget, preToolUseDecision, READ_ONLY_TOOLS, shellHookCall, tabToolsMcpServers, withSessionTokenMasked } from "./claude-agent-sdk-query-options.ts";
 import { localServerBaseUrl } from "../services/server-listen-address.ts";
 import { TAB_TOOLS_MCP_PATH, tabToolsMcpAccessFor } from "../services/tab-tools-mcp/tab-tools-mcp-tokens.ts";
 import { DB_TOOLS_MCP_PATH, dbToolsMcpAccessFor } from "../services/db-ai-tools/db-ai-tools-tokens.ts";
@@ -19,6 +19,10 @@ import { captureBaseline } from "../services/session-file-baselines/session-file
 import { observeFile } from "../services/session-file-baselines/session-file-history.ts";
 import { beginShellCommand, endShellCommand, noteFileToolWrite } from "../services/session-file-baselines/shell-change-tracker.ts";
 import { WarmSpares, spawnFingerprint } from "./claude-warm-spare.ts";
+import { APPROVAL_WAKE, ApprovalQueue } from "./claude-approval-queue.ts";
+import { EFFORT_ENV_VAR, effortStatusFromCli, estimateEffortStatus, userSettingsFile, type EffortSettingsQuery } from "./claude-effort-status.ts";
+import type { EffortStatus } from "../shared/effort-status.ts";
+import { withTimeout } from "../services/mcp-oauth/mcp-control-query.ts";
 import { CLAUDE_DESIGN_CHECK_TOOL } from "../services/design/mcp/design-mcp-tool.ts";
 import { designToolDecision } from "../services/design/design-tool-policy.ts";
 import { CLAUDE_MODELS } from "../types/claude-models.ts";
@@ -62,6 +66,8 @@ const usageLog = createLogger("usage");
 const mcpControlLog = createLogger("mcp-control");
 
 const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
+/** A running CLI answers `get_settings` in a few ms; this only bounds one that never does. */
+const EFFORT_READ_TIMEOUT_MS = 5_000;
 
 /**
  * Resolve the Claude CLI the SDK should spawn.
@@ -283,6 +289,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
    * and this is the only place that knows what made it do so.
    */
   private teardownReasons = new Map<string, string>();
+  /** The `--effort` each session's CLI was started with, to set beside what it reports sending. */
+  private startedEffort = new Map<string, string | null>();
   /** The API's last rate-limit status per account and limit, so only a change is logged. */
   private rateLimitStatus = new Map<string, string>();
   /** CLIs started for chats that do not exist yet — see `prewarm`. */
@@ -738,6 +746,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       }
     }
     this.forkSources.delete(sessionId);
+    this.startedEffort.delete(sessionId);
 
     // Best-effort: delete JSONL from ~/.claude/projects/
     try {
@@ -933,7 +942,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       ...(p.forkSession && { forkSession: true }),
       cwd: p.cwd,
       systemPrompt: p.systemPrompt,
-      settingSources: ["user", "project"],
+      settingSources: [...CLAUDE_SETTING_SOURCES],
       env: p.env,
       settings: { permissions: { allow: [], deny: [] } },
       allowedTools: p.allowedTools,
@@ -1177,12 +1186,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     const dbToolsMcp = opts?.designSession ? undefined : opts?.dbToolsMcp;
     const allowedTools = allowedToolsFor({ isBypass, agentTeams: providerConfig.agent_teams, designPolicy, designCheckTool });
 
-    /**
-     * Approval events to yield from the generator.
-     * PreToolUse hook pushes events here; the main loop yields them.
-     */
-    const approvalEvents: ChatEvent[] = [];
-    let approvalNotify: (() => void) | undefined;
+    /** Approval requests from canUseTool and the PreToolUse hook, handed out by the main loop. */
+    const approvals = new ApprovalQueue<ChatEvent>();
 
     /**
      * Helper: send approval request to FE and wait for response.
@@ -1193,8 +1198,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       const promise = new Promise<{ approved: boolean; data?: unknown }>((resolve) => {
         this.pendingApprovals.set(requestId, { resolve, sessionId });
       });
-      approvalEvents.push({ type: "approval_request", requestId, tool: toolName, input });
-      approvalNotify?.();
+      approvals.push({ type: "approval_request", requestId, tool: toolName, input });
       return promise;
     };
 
@@ -1460,6 +1464,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         providerConfig,
         stderr: stderrCallback,
       });
+      // Every retry below restarts the CLI with these same options.
+      this.startedEffort.set(sessionId, (queryOptions.effort as string | undefined) ?? null);
 
       // Crash retry: if subprocess exits with non-zero code before producing events,
       // clean up and retry once with a fresh query before surfacing the error.
@@ -1610,7 +1616,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       assistantContent = "";
       pendingToolCount = 0;
       let sdkEventCount = 0;
-      for await (const msg of eventSource) {
+      for await (const msg of approvals.alongside(eventSource)) {
+        // An approval goes out now: the CLI sends nothing more until it is answered.
+        if (msg === APPROVAL_WAKE) {
+          yield* approvals.drain();
+          continue;
+        }
         sdkEventCount++;
         hadAnyEvents = true;
         if (sdkEventCount === 1) {
@@ -1640,9 +1651,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         const parentId = (msg as any).parent_tool_use_id as string | undefined;
 
         // Yield any queued approval events
-        while (approvalEvents.length > 0) {
-          yield approvalEvents.shift()!;
-        }
+        yield* approvals.drain();
 
         // Log system events for debugging SDK lifecycle: the subtype only, never the message.
         // thinking_tokens and status=requesting arrive at token rate, so not even at DEBUG.
@@ -2430,9 +2439,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       }
 
       // Yield remaining approval events
-      while (approvalEvents.length > 0) {
-        yield approvalEvents.shift()!;
-      }
+      yield* approvals.drain();
 
       if (!hadAnyEvents) {
         yield { type: "error", message: "Claude did not respond. Check that 'claude' CLI works in your terminal." };
@@ -2533,7 +2540,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         ...(needsNodeInterpreter(process.platform, cliExecutablePath) && { executable: "node" }),
         ...(cliExecutablePath && { pathToClaudeCodeExecutable: cliExecutablePath }),
         cwd,
-        settingSources: ["user", "project"],
+        settingSources: [...CLAUDE_SETTING_SOURCES],
         // No account: MCP OAuth tokens belong to the CLI's own credential store, the same
         // one an interactive `claude` writes, and no model call is ever made here.
         env: this.buildQueryEnv(cwd, null),
@@ -2578,6 +2585,39 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     }
   }
 
+  /**
+   * The effort this session's CLI sends and what overrides the pick, asked of the CLI itself:
+   * `CLAUDE_CODE_EFFORT_LEVEL`, a settings cap, an organization limit and the model's own levels
+   * all count there, while the `--effort` PPM passed is only one input to it. Null when the
+   * session has no live subprocess or the CLI does not answer.
+   */
+  async readEffortStatus(sessionId: string): Promise<EffortStatus | null> {
+    const ss = this.streamingSessions.get(sessionId);
+    if (!ss) return null;
+    const cli = ss.query as unknown as EffortSettingsQuery;
+    try {
+      const [answer, init] = await Promise.all([
+        withTimeout(cli.getSettings(), EFFORT_READ_TIMEOUT_MS, "Claude did not report its settings"),
+        withTimeout(cli.initializationResult(), EFFORT_READ_TIMEOUT_MS, "Claude did not report its models").catch(() => undefined),
+      ]);
+      return effortStatusFromCli({
+        answer,
+        models: init?.models,
+        requested: this.startedEffort.get(sessionId),
+        processEnv: process.env[EFFORT_ENV_VAR],
+        userFile: userSettingsFile(process.env).shown,
+      });
+    } catch (e) {
+      log.debug(`session=${sessionId} effort status unavailable: ${(e as Error).message}`);
+      return null;
+    }
+  }
+
+  /** What the settings files say about effort for a chat in `projectPath` no CLI has answered for yet. */
+  estimateEffortStatus(projectPath: string | undefined, model?: string): EffortStatus {
+    return estimateEffortStatus({ projectPath, model, env: process.env });
+  }
+
   /** Abort and fully teardown the streaming session — user must resume to continue */
   abortQuery(sessionId: string, source = "unknown"): void {
     const ss = this.streamingSessions.get(sessionId);

package/src/providers/claude-approval-queue.ts

@@ -0,0 +1,75 @@
+/** What `alongside` yields instead of a message when only the queue has something to hand out. */
+export const APPROVAL_WAKE = Symbol("approval-wake");
+
+/**
+ * Approval requests raised from the CLI's callbacks (`canUseTool`, the PreToolUse hook), for the
+ * turn's loop over the CLI's messages to hand out.
+ *
+ * The CLI asks through a control request and then says nothing until it is answered, so a queue
+ * looked at only when the next message arrives can wait forever: an AskUserQuestion stayed behind
+ * a thinking spinner for 17 minutes, until the user cancelled. Whether the turn's last message
+ * landed before or after the callback ran decided it, which is why it looked intermittent.
+ */
+export class ApprovalQueue<E> {
+  private readonly queued: E[] = [];
+  private wake: (() => void) | undefined;
+
+  push(event: E): void {
+    this.queued.push(event);
+    this.wake?.();
+  }
+
+  *drain(): Generator<E> {
+    while (this.queued.length > 0) yield this.queued.shift()!;
+  }
+
+  /**
+   * `source`'s items, plus `APPROVAL_WAKE` whenever something is queued and `source` has nothing
+   * to give. The caller must drain the queue on a wake, or it is woken again at once.
+   */
+  async *alongside<T>(source: AsyncIterable<T>): AsyncGenerator<T | typeof APPROVAL_WAKE> {
+    const it = source[Symbol.asyncIterator]();
+    // Kept across wakes: a second next() would hand this item to a promise nobody reads.
+    let next: Promise<IteratorResult<T>> | undefined;
+    // Closed on an early exit, as `for await` closes it: not once it has ended or thrown.
+    let open = true;
+    try {
+      for (;;) {
+        if (this.queued.length > 0) {
+          yield APPROVAL_WAKE;
+          continue;
+        }
+        const pending = (next ??= it.next());
+        let got: IteratorResult<T> | typeof APPROVAL_WAKE;
+        try {
+          got = await new Promise<IteratorResult<T> | typeof APPROVAL_WAKE>((resolve, reject) => {
+            this.wake = () => resolve(APPROVAL_WAKE);
+            // next() may have run a callback that queued something before there was a wake to call.
+            if (this.queued.length > 0) this.wake();
+            pending.then(resolve, reject);
+          });
+        } catch (e) {
+          open = false;
+          throw e;
+        } finally {
+          this.wake = undefined;
+        }
+        if (got === APPROVAL_WAKE) continue;
+        next = undefined;
+        if (got.done) {
+          open = false;
+          return;
+        }
+        yield got.value;
+      }
+    } finally {
+      if (open && next) {
+        // Not awaited: an async generator's return() waits behind the next() still out, which
+        // the CLI answers only after the approval it is waiting on.
+        Promise.resolve().then(() => it.return?.()).catch(() => {});
+      } else if (open) {
+        await it.return?.();
+      }
+    }
+  }
+}

package/src/providers/claude-effort-status.ts

@@ -0,0 +1,211 @@
+/**
+ * What decides a Claude session's effort besides the pick, worked out from the same settings
+ * the CLI reads. The live answer comes from the running CLI (`readEffortStatus` in the
+ * provider); until a turn has started one, `estimateEffortStatus` reads the settings files
+ * the CLI would, which is enough for the common overrides and is replaced by the CLI's own
+ * answer as soon as there is one.
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import * as nodePath from "node:path";
+import { join } from "node:path";
+import {
+  effortEnvMeaning, effortRank, isEffortLevel,
+  type EffortLevel, type EffortSetting, type EffortSettingSource, type EffortStatus,
+} from "../shared/effort-status.ts";
+import { CLAUDE_SETTING_SOURCES, type ClaudeSettingSource } from "./claude-agent-sdk-query-options.ts";
+
+export const EFFORT_ENV_VAR = "CLAUDE_CODE_EFFORT_LEVEL";
+
+/** One entry of `get_settings`'s `sources`, which the CLI orders from lowest priority to highest. */
+export interface CliSettingsSource {
+  source: string;
+  settings: Record<string, unknown>;
+}
+
+/**
+ * The part of the `get_settings` answer read here. `getSettings()` is on the SDK's `Query`
+ * object but left out of `sdk.d.ts`, which is why this is typed here; a test asserts the SDK
+ * still has it, so an upgrade that renames it fails loudly instead of the status going quiet.
+ */
+export interface CliSettingsAnswer {
+  sources?: Array<CliSettingsSource | null>;
+  /** What the session sends after env overrides, caps and model downgrades. */
+  applied?: { model?: string; effort?: string | null };
+}
+
+/** A model as the CLI's `initialize` answer lists it. */
+export interface CliModelInfo {
+  value: string;
+  resolvedModel?: string;
+  supportedEffortLevels?: string[];
+}
+
+export interface EffortSettingsQuery {
+  getSettings(): Promise<CliSettingsAnswer>;
+  initializationResult(): Promise<{ models?: CliModelInfo[] }>;
+}
+
+type PathApi = Pick<typeof nodePath, "join" | "relative" | "isAbsolute" | "sep">;
+
+/**
+ * Where the CLI keeps its user settings; `~/` stands in for the home folder in what is shown.
+ * Decided with `relative` rather than a `${home}/` prefix, which never matches a Windows path.
+ */
+export function userSettingsFile(
+  env: Record<string, string | undefined>,
+  home = homedir(),
+  path: PathApi = nodePath,
+): { path: string; shown: string } {
+  const file = path.join(env.CLAUDE_CONFIG_DIR || path.join(home, ".claude"), "settings.json");
+  const rel = path.relative(home, file);
+  const inHome = rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+  return { path: file, shown: inHome ? `~/${rel.split(path.sep).join("/")}` : file };
+}
+
+const FILE_OF: Partial<Record<EffortSettingSource, string>> = {
+  projectSettings: ".claude/settings.json",
+  localSettings: ".claude/settings.local.json",
+};
+
+function place(source: string, userFile: string): Pick<EffortSetting<unknown>, "source" | "file"> {
+  const known = source as EffortSettingSource;
+  const file = source === "userSettings" ? userFile : FILE_OF[known];
+  return { source: known, ...(file && { file }) };
+}
+
+/** `modelSettings` keys name a model the way its dated, `[1m]`, Bedrock and Vertex spellings all match. */
+function modelKey(model: string): string {
+  return model.toLowerCase()
+    .replace(/\[[^\]]*\]$/, "")
+    .replace(/@.*$/, "")
+    .replace(/-v\d+(?::\d+)?$/, "")
+    .replace(/^(?:[a-z-]+\.)?anthropic\./, "")
+    .replace(/-\d{8}$/, "");
+}
+
+/** A source's own cap for the model: a matching `modelSettings` entry replaces its `maxEffortLevel`. */
+function sourceCap(settings: Record<string, unknown>, model: string | undefined): unknown {
+  const perModel = settings.modelSettings;
+  if (model && perModel && typeof perModel === "object") {
+    const key = modelKey(model);
+    let lowest: EffortLevel | undefined;
+    for (const [name, entry] of Object.entries(perModel as Record<string, unknown>)) {
+      const level = (entry as { maxEffortLevel?: unknown } | null)?.maxEffortLevel;
+      if (modelKey(name) !== key || !isEffortLevel(level)) continue;
+      if (!lowest || effortRank(level) < effortRank(lowest)) lowest = level;
+    }
+    if (lowest) return lowest;
+  }
+  return settings.maxEffortLevel;
+}
+
+/**
+ * The overrides the settings and the environment hold: the `CLAUDE_CODE_EFFORT_LEVEL` that wins
+ * (the highest-priority settings file that sets it, else the environment, which every settings
+ * file outranks) and the lowest cap (across files the lowest wins, and "max" caps nothing).
+ */
+export function effortOverrides(p: {
+  sources: ReadonlyArray<CliSettingsSource | null | undefined>;
+  processEnv?: string;
+  model?: string;
+  userFile: string;
+}): Pick<EffortStatus, "env" | "cap"> {
+  const out: Pick<EffortStatus, "env" | "cap"> = {};
+  const sources = p.sources.filter((s): s is CliSettingsSource => !!s?.settings && typeof s.settings === "object");
+
+  let env: EffortSetting<string> | undefined;
+  for (let i = sources.length - 1; i >= 0 && !env; i--) {
+    const value = (sources[i]!.settings.env as Record<string, unknown> | undefined)?.[EFFORT_ENV_VAR];
+    if (typeof value === "string") env = { value, ...place(sources[i]!.source, p.userFile) };
+  }
+  env ??= p.processEnv !== undefined ? { value: p.processEnv, source: "environment" } : undefined;
+  // A value the CLI ignores overrides nothing — but it still hides a lower one, as it does there.
+  if (env && effortEnvMeaning(env.value)) out.env = env;
+
+  for (const s of sources) {
+    const level = sourceCap(s.settings, p.model);
+    if (!isEffortLevel(level) || level === "max") continue;
+    if (!out.cap || effortRank(level) < effortRank(out.cap.value)) out.cap = { value: level, ...place(s.source, p.userFile) };
+  }
+  return out;
+}
+
+function levels(values: unknown): EffortLevel[] {
+  return Array.isArray(values) ? values.filter(isEffortLevel) : [];
+}
+
+/** The model's levels, from the `initialize` answer; undefined when it lists no such model. */
+export function supportedLevels(models: CliModelInfo[] | undefined, model: string | undefined): EffortLevel[] | undefined {
+  if (!models || !model) return undefined;
+  const bare = (name: string) => name.toLowerCase().replace(/\[[^\]]*\]$/, "");
+  const hit = models.find((m) => [m.value, m.resolvedModel].some((name) => name && bare(name) === bare(model)));
+  return hit ? levels(hit.supportedEffortLevels) : undefined;
+}
+
+/** The running CLI's answer, as a status: its overrides plus what it said it sends. */
+export function effortStatusFromCli(p: {
+  answer: CliSettingsAnswer;
+  models?: CliModelInfo[];
+  requested: string | null | undefined;
+  processEnv?: string;
+  userFile: string;
+}): EffortStatus {
+  const model = typeof p.answer.applied?.model === "string" ? p.answer.applied.model : undefined;
+  const applied = p.answer.applied?.effort;
+  const supported = supportedLevels(p.models, model);
+  return {
+    ...effortOverrides({ sources: p.answer.sources ?? [], processEnv: p.processEnv, model, userFile: p.userFile }),
+    observed: {
+      requested: isEffortLevel(p.requested) ? p.requested : null,
+      applied: isEffortLevel(applied) ? applied : null,
+      ...(model && { model }),
+    },
+    ...(supported && { supported }),
+  };
+}
+
+/**
+ * The settings files a chat in `projectPath` reads, lowest priority first: those of the sources
+ * its CLI is started with, so the estimate never counts a file the chat does not load. A file
+ * that does not parse is skipped, as the CLI skips it.
+ */
+export function readSettingsFiles(
+  projectPath: string | undefined,
+  userPath: string,
+  sources: readonly ClaudeSettingSource[] = CLAUDE_SETTING_SOURCES,
+): CliSettingsSource[] {
+  const fileOf: Record<ClaudeSettingSource, [EffortSettingSource, string] | null> = {
+    user: ["userSettings", userPath],
+    project: projectPath ? ["projectSettings", join(projectPath, ".claude", "settings.json")] : null,
+    local: projectPath ? ["localSettings", join(projectPath, ".claude", "settings.local.json")] : null,
+  };
+  const files = sources.map((source) => fileOf[source]).filter((f): f is [EffortSettingSource, string] => !!f);
+  const out: CliSettingsSource[] = [];
+  for (const [source, file] of files) {
+    let settings: unknown;
+    try { settings = JSON.parse(readFileSync(file, "utf8")); } catch { continue; }
+    if (settings && typeof settings === "object" && !Array.isArray(settings)) out.push({ source, settings: settings as Record<string, unknown> });
+  }
+  return out;
+}
+
+/**
+ * The overrides a chat in `projectPath` will meet, from the files alone — for a session no CLI
+ * has answered for yet. Managed settings and organization limits are left to the CLI's answer.
+ */
+export function estimateEffortStatus(p: {
+  projectPath?: string;
+  model?: string;
+  env?: Record<string, string | undefined>;
+  home?: string;
+}): EffortStatus {
+  const env = p.env ?? process.env;
+  const user = userSettingsFile(env, p.home);
+  return effortOverrides({
+    sources: readSettingsFiles(p.projectPath, user.path),
+    processEnv: env[EFFORT_ENV_VAR],
+    model: p.model,
+    userFile: user.shown,
+  });
+}

package/src/providers/registry.ts

@@ -5,6 +5,7 @@ import { configService } from "../services/config.service.ts";
 import { nextProbeDelayMs, type ProviderProbeStatus } from "./provider-probe.ts";
 import { CODEX_DEFAULT_MODEL } from "../types/config.ts";
 import { createLogger } from "../services/logger.ts";
+import { registerMemoryGauge } from "../services/memory-diagnostics.ts";
 
 const log = createLogger("registry");
 
@@ -53,7 +54,13 @@ class ProviderRegistry {
 export const providerRegistry = new ProviderRegistry();
 
 // SDK providers registered synchronously (no binary check needed)
-providerRegistry.register(new ClaudeAgentSdkProvider());
+const claudeProvider = new ClaudeAgentSdkProvider();
+providerRegistry.register(claudeProvider);
+// Sizes for the opt-in memory monitor (PPM_MEM_DIAG). Bracket access reaches the private
+// maps without widening the class; registering costs nothing while the monitor is off.
+registerMemoryGauge("claude.streamingSessions", () => claudeProvider["streamingSessions"].size);
+registerMemoryGauge("claude.activeQueries", () => claudeProvider["activeQueries"].size);
+registerMemoryGauge("claude.activeSessions", () => claudeProvider["activeSessions"].size);
 providerRegistry.register(new MockProvider()); // testing only
 
 /**
@@ -176,6 +183,8 @@ async function probeCodexProvider(): Promise<ProviderProbeStatus> {
       const result = await codex.probe();
       if (result.ok) {
         providerRegistry.register(codex);
+        registerMemoryGauge("codex.sessions", () => codex["sessions"].size);
+        registerMemoryGauge("codex.live", () => codex["live"].size);
         ensureCodexConfigEntry();
         log.info("Codex provider registered (@openai/codex found)");
         status = { id: "codex", registered: true, attempts, lastProbeAt };

package/src/server/index.ts

@@ -1,5 +1,4 @@
 import { Hono } from "hono";
-import { cors } from "hono/cors";
 import { writeFileSync } from "node:fs";
 import { SERVER_PORT_FILE } from "../services/edge-target-resolver.ts";
 import { configService } from "../services/config.service.ts";
@@ -7,6 +6,7 @@ import { VERSION } from "../version.ts";
 import { authMiddleware } from "./middleware/auth.ts";
 import { gzipJson } from "./middleware/gzip-json.ts";
 import { accessLog } from "./middleware/access-log.ts";
+import { corsHeaders } from "./middleware/cors-headers.ts";
 import { createLogger } from "../services/logger.ts";
 import { projectRoutes } from "./routes/projects.ts";
 import { settingsRoutes } from "./routes/settings.ts";
@@ -167,14 +167,15 @@ app.onError((error, c) => {
   return c.text("Internal Server Error", 500);
 });
 
-// Design share links: the public reviewer surface. Ahead of `cors()` (which would answer `*`
-// and re-wrap range bodies), of `/api` auth (a share code is never the PPM token) and of the
-// static fallback (its catch-all keeps every `/s` path off the app shell).
+// Design share links: the public reviewer surface. Ahead of the CORS layer, of `/api` auth
+// (a share code is never the PPM token) and of the static fallback (its catch-all keeps every
+// `/s` path off the app shell).
 import { designShareGuestRoutes } from "./routes/design-share-guest.ts";
 app.route("/s", designShareGuestRoutes);
 
-// CORS for dev
-app.use("*", cors());
+// CORS for dev. Not Hono's `cors()`: it writes headers before the handler, which makes Hono
+// rebuild every response from its body and turns a `Bun.file` body into a leaking stream.
+app.use("*", corsHeaders);
 
 // Public endpoints (before auth)
 // Per-boot id so a named-tunnel health probe can tell "my connector is dark"

package/src/server/middleware/access-log.ts

@@ -13,6 +13,7 @@
  */
 import type { MiddlewareHandler } from "hono";
 import { createLogger, type LogLevel } from "../../services/logger.ts";
+import { requestTracker } from "../../services/memory-diagnostics-requests.ts";
 
 const log = createLogger("http");
 
@@ -119,6 +120,8 @@ export const accessLog: MiddlewareHandler = async (c, next) => {
   const ms = Math.round(performance.now() - started);
   const url = new URL(c.req.url);
   const status = c.res.status;
+  // Before the level check: the memory monitor counts every request, logged or not.
+  requestTracker.record(c.req.method, url.pathname, c.res.headers.get("content-length"));
   const level = accessLogLevel(c.req.method, url.pathname, status, ms);
   if (!log.isEnabled(level)) return;
   const line = `${c.req.method} ${describeRequestTarget(url)} ${status} ${ms}ms${ms >= SLOW_REQUEST_MS ? " (slow)" : ""}`;

package/src/server/middleware/cors-headers.ts

@@ -0,0 +1,44 @@
+import type { MiddlewareHandler } from "hono";
+
+/**
+ * The app-wide CORS headers, written onto the handler's own response AFTER it is made.
+ *
+ * Hono's `cors()` sets its headers on `c.res` before `next()`, which makes Hono build a
+ * placeholder response; when the handler then returns its own, the `c.res` setter rebuilds it
+ * as `new Response(res.body, res)` to merge the two. Reading `.body` turns a `Bun.file(...)`
+ * body into Bun's file stream — the one that keeps about the file's size in native memory per
+ * response and never returns it (see `services/file-chunks.ts`). Measured on Bun 1.3.10
+ * (Windows), a 23 MB file: 2.9 MB per response bare, 30.2 MB behind `cors()`, and the
+ * response lost its `Content-Length` (sent chunked). Every static asset, chat image and
+ * download went through that.
+ *
+ * Same answer as `cors()` with its defaults (`origin: "*"`), with one difference: a route that
+ * sets `Access-Control-Allow-Origin` itself keeps it (`cors()` overwrote it, which is why the
+ * design preview had to re-assert `null`).
+ */
+const ALLOW_METHODS = "GET,HEAD,PUT,POST,DELETE,PATCH";
+
+export const corsHeaders: MiddlewareHandler = async (c, next) => {
+  if (c.req.method === "OPTIONS") {
+    // A preflight never reaches a handler, so answering it here rebuilds nothing.
+    const headers = new Headers({ "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": ALLOW_METHODS });
+    const requested = c.req.header("Access-Control-Request-Headers");
+    if (requested) {
+      headers.set("Access-Control-Allow-Headers", requested.split(/\s*,\s*/).join(","));
+      headers.append("Vary", "Access-Control-Request-Headers");
+    }
+    return new Response(null, { status: 204, statusText: "No Content", headers });
+  }
+
+  await next();
+  if (c.res.headers.has("Access-Control-Allow-Origin")) return;
+  try {
+    c.res.headers.set("Access-Control-Allow-Origin", "*");
+  } catch {
+    // A response whose headers are immutable (one passed through from `fetch`) is rebuilt;
+    // its body is a stream already, so there is no file to turn into one.
+    const res = new Response(c.res.body, c.res);
+    res.headers.set("Access-Control-Allow-Origin", "*");
+    c.res = res;
+  }
+};

package/src/server/routes/chat.ts

@@ -166,6 +166,23 @@ chatRoutes.get("/providers/:providerId/models", async (c) => {
   }
 });
 
+/**
+ * GET /chat/providers/:providerId/effort-status?model= — what overrides the effort picked for a
+ * new chat in this project (`CLAUDE_CODE_EFFORT_LEVEL`, a `maxEffortLevel` cap), from the settings
+ * files; a session's own socket carries the CLI's answer once a turn has run. `status` is null
+ * for a provider nothing overrides.
+ */
+chatRoutes.get("/providers/:providerId/effort-status", (c) => {
+  const provider = providerRegistry.get(c.req.param("providerId"));
+  if (!provider) return c.json(err(`Provider "${c.req.param("providerId")}" not found`), 404);
+  try {
+    const status = provider.estimateEffortStatus?.(c.get("projectPath"), c.req.query("model") || undefined) ?? null;
+    return c.json(ok({ status }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 /** GET /chat/sessions — list chat sessions filtered by project from context */
 chatRoutes.get("/sessions", async (c) => {
   try {
@@ -1277,7 +1294,10 @@ chatRoutes.get("/uploads/:filename", async (c) => {
     if (c.req.header("if-none-match") === etag) {
       return new Response(null, { status: 304, headers: { ETag: etag } });
     }
-    return new Response(file.stream(), {
+    // The file itself, not `file.stream()`: that stream keeps about the file's size in native
+    // memory per response and never returns it (see `file-chunks.ts`), and chat images are
+    // served every time a tab opens without them cached.
+    return new Response(file, {
       headers: {
         "Content-Type": file.type || "application/octet-stream",
         "Cache-Control": "public, max-age=31536000, immutable",

package/src/server/routes/database-impexp.ts

@@ -310,7 +310,7 @@ impExpJobRoutes.post("/jobs/:id/download", async (c) => {
   const ticket = issueExportTicket({
     fileName: file.name,
     contentType: file.format === "zip" ? "application/zip" : CONTENT_TYPES[file.format],
-    open: () => Bun.file(file.path).stream(),
+    open: () => Bun.file(file.path),
     abandon: () => {},
   });
   return c.json(ok<GridExportTicket>({ ticket, fileName: file.name }));