@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/{artifact-sdk → pages}/feedback-overlay.ts

@@ -25,6 +25,43 @@ export function isPageFeedbackRequested(queryParams: URLSearchParams): boolean {
   return value !== "0" && value !== "false";
 }
 
+// Keys typed in the overlay must never reach the page's own key handlers. A
+// listener on the overlay runs too late: page capture listeners on window and
+// document fire first. So this guard is served at the top of <head>, before any
+// page script, and is the first window capture listener. For a key from the
+// overlay it stops dispatch outright and hands the event to the overlay
+// (window.__swarmFeedbackKeys.handle). A press that started in the overlay
+// stays owned until its keyup, so the release is swallowed even after the
+// composer closed and focus moved to the page. Every other key passes through.
+// The overlay script repeats it as a fallback; the second run is a no-op.
+const FEEDBACK_KEY_GUARD_JS = `
+(function () {
+  if (window.__swarmFeedbackKeys) return;
+  var keys = window.__swarmFeedbackKeys = { host: null, handle: null };
+  var owned = {};
+  function id(e) { return e.code || e.key; }
+  function fromOverlay(e) {
+    return !!keys.host && typeof e.composedPath === 'function' && e.composedPath().indexOf(keys.host) !== -1;
+  }
+  function guard(e) {
+    var k = id(e);
+    var mine = fromOverlay(e);
+    if (!mine && !owned[k]) return;
+    if (e.type === 'keydown') {
+      if (mine) owned[k] = true;
+      else if (!e.repeat) { delete owned[k]; return; }
+    }
+    if (e.type === 'keyup') delete owned[k];
+    e.stopImmediatePropagation();
+    if (mine && keys.handle) keys.handle(e);
+  }
+  ['keydown', 'keypress', 'keyup'].forEach(function (type) {
+    window.addEventListener(type, guard, true);
+  });
+  window.addEventListener('blur', function () { owned = {}; });
+})();
+`;
+
 const FEEDBACK_OVERLAY_JS = `
 (function () {
   var cfg = window.__swarmFeedback;
@@ -135,6 +172,7 @@ const FEEDBACK_OVERLAY_JS = `
   var panel = document.createElement('div');
   panel.className = 'panel';
   var composer = null;
+  var composerInput = null;
   root.appendChild(hl);
   root.appendChild(markers);
   root.appendChild(panel);
@@ -207,11 +245,25 @@ const FEEDBACK_OVERLAY_JS = `
     }
     render();
   }
-  document.addEventListener('keydown', function (e) {
-    if (e.key !== 'Escape') return;
+  function onEscape() {
     if (state.draft) { closeComposer(); return; }
     if (state.selecting) setSelecting(false);
+  }
+  // Escape pressed on the page while selecting. Keys typed in the overlay never
+  // get here: the key guard stops them and calls onOverlayKey instead.
+  document.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape') onEscape();
   }, true);
+  function onOverlayKey(e) {
+    if (e.type !== 'keydown') return;
+    if (e.key === 'Escape') { onEscape(); return; }
+    if (e.key === 'Enter' && (e.metaKey || e.ctrlKey) && composerInput && e.composedPath()[0] === composerInput) {
+      e.preventDefault();
+      commitDraft(composerInput.value);
+    }
+  }
+  window.__swarmFeedbackKeys.host = host;
+  window.__swarmFeedbackKeys.handle = onOverlayKey;
 
   // ─── Composer ──────────────────────────────────────────────────────────
   function openComposer(target) {
@@ -230,9 +282,7 @@ const FEEDBACK_OVERLAY_JS = `
     add.type = 'button';
     cancel.addEventListener('click', closeComposer);
     add.addEventListener('click', function () { commitDraft(input.value); });
-    input.addEventListener('keydown', function (e) {
-      if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) { e.preventDefault(); commitDraft(input.value); }
-    });
+    composerInput = input;
     row.appendChild(cancel);
     row.appendChild(add);
     composer.appendChild(row);
@@ -253,6 +303,7 @@ const FEEDBACK_OVERLAY_JS = `
   function closeComposer() {
     if (composer) composer.remove();
     composer = null;
+    composerInput = null;
     state.draft = null;
     hideHighlight();
   }
@@ -524,5 +575,13 @@ const FEEDBACK_OVERLAY_JS = `
  */
 export function feedbackOverlayScripts(pageId: string): string {
   const config = JSON.stringify({ pageId }).replace(/</g, "\\u003c");
-  return `<script>window.__swarmFeedback = ${config};</script><script>${FEEDBACK_OVERLAY_JS}</script>`;
+  return `<script>window.__swarmFeedback = ${config};</script><script>${FEEDBACK_KEY_GUARD_JS}${FEEDBACK_OVERLAY_JS}</script>`;
+}
+
+/**
+ * Key guard served at the top of `<head>` when feedback mode is on, so it runs
+ * before any page script and its window capture listeners come first.
+ */
+export function feedbackKeyGuardScript(): string {
+  return `<script>${FEEDBACK_KEY_GUARD_JS}</script>`;
 }

package/src/pages/version.ts

@@ -1,4 +1,5 @@
-import { createPageVersion, getPage, getPageVersions } from "../be/db";
+import { createPageVersion, getPage } from "../be/db";
+import { getPageEditCounter } from "../be/db/page-versions";
 import type { PageSnapshot, PageVersion } from "../types";
 
 /**
@@ -8,7 +9,7 @@ import type { PageSnapshot, PageVersion } from "../types";
  * Mirrors `snapshotWorkflow` (src/workflows/version.ts:13-44).
  *
  * 1. Load current page state
- * 2. Get max version number for this page (page_versions ORDER BY version DESC)
+ * 2. Get max version number for this page (MAX(page_versions.version))
  * 3. Insert page_versions row with version+1 and the pre-update snapshot
  *
  * Throws on missing parent. Callers in HTTP handlers wrap this in a try/catch
@@ -24,9 +25,7 @@ export async function snapshotPage(
     throw new Error(`Page ${pageId} not found — cannot create snapshot`);
   }
 
-  const existingVersions = await getPageVersions(pageId);
-  const maxVersion = existingVersions.length > 0 ? existingVersions[0]!.version : 0;
-  const nextVersion = maxVersion + 1;
+  const nextVersion = await getPageEditCounter(pageId);
 
   const snapshot: PageSnapshot = {
     title: page.title,

package/src/prompts/base-prompt.ts

@@ -8,11 +8,15 @@
  *   E          outputs (gated on AGENT_FS_API_URL and the pages capability)
  *   H          deployment-gated notes: slack, steering
  *   I          tools and skills (harness tool discovery, skills, MCP server names)
- *   J          agent notes: CLAUDE.md for codex, opencode, pi, only when edited
- *   K          repository (per task)
+ *   J          agent notes: CLAUDE.md, only when edited
  *
- * The runner appends the requester profile, the operator SYSTEM_PROMPT, and a
- * cwd warning after this.
+ * The runner appends the operator SYSTEM_PROMPT after this.
+ *
+ * Nothing here may vary per task, requester, or session: the provider caches
+ * the system prompt as a prefix, and one changed byte re-bills everything
+ * after it. Per-task context (repository, scripts-only Slack, requester
+ * profile, cwd warning) goes into the task prompt instead; see
+ * `getTaskContextPrompt` and the runner's `buildTaskSessionPrompts`.
  */
 
 import type { ProviderTraits } from "../providers/types";
@@ -44,13 +48,28 @@ const BOOTSTRAP_TOTAL_MAX_CHARS = 120_000;
 
 /**
  * Per-section cap applied to the *repo* CLAUDE.md when it is inlined (opencode
- * only). The agent-swarm OSS one is ~18 KB and the biggest volatile component
- * of the system prompt.
+ * only). The agent-swarm OSS one is ~18 KB and the biggest piece of the task
+ * context.
  */
 const REPO_CLAUDE_MD_MAX_CHARS = 12_000;
 
-/** Providers that do not load the agent's CLAUDE.md natively. Claude does. */
-const CLAUDE_MD_INJECT_PROVIDERS: ReadonlySet<string> = new Set(["codex", "opencode", "pi"]);
+/**
+ * Providers that get the agent's CLAUDE.md in the system prompt. Claude also
+ * keeps the editable copy at ~/.claude/CLAUDE.md but excludes it from its
+ * memory load (claude-flag-settings.ts), so it is read once, from the cached
+ * system prompt instead of an uncached message.
+ */
+const CLAUDE_MD_INJECT_PROVIDERS: ReadonlySet<string> = new Set([
+  "claude",
+  "codex",
+  "opencode",
+  "pi",
+]);
+
+/** Where each provider's editable CLAUDE.md lives, for the truncation notice. */
+function claudeMdSourcePath(provider: string): string {
+  return provider === "claude" ? "~/.claude/CLAUDE.md" : "/workspace/CLAUDE.md";
+}
 
 /** Providers that get the repo CLAUDE.md inlined until native loading is verified. */
 const REPO_CLAUDE_MD_INLINE_PROVIDERS: ReadonlySet<string> = new Set(["opencode"]);
@@ -95,36 +114,61 @@ export type BasePromptArgs = {
   soulMd?: string;
   identityMd?: string;
   claudeMd?: string;
-  repoContext?: {
-    claudeMd?: string | null;
-    clonePath: string;
-    warning?: string | null;
-    autoStashes?: { ref: string; message: string }[];
-    guidelines?: {
-      prChecks: string[];
-      mergeChecks: string[];
-      allowMerge?: boolean;
-      review: string[];
-    } | null;
-  };
-  /** Slack context from the current task, if present */
-  slackContext?: { channelId: string; threadTs?: string };
   /** Pre-fetched skill summaries for the tools and skills section */
   skillsSummary?: { name: string; description: string }[];
   /** Names of the MCP servers connected for this agent */
   mcpServers?: string[];
 };
 
-export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
-  const { role, agentId, traits } = args;
+export type RepoContext = {
+  claudeMd?: string | null;
+  clonePath: string;
+  warning?: string | null;
+  autoStashes?: { ref: string; message: string }[];
+  guidelines?: {
+    prChecks: string[];
+    mergeChecks: string[];
+    allowMerge?: boolean;
+    review: string[];
+  } | null;
+};
+
+export type SlackTaskContext = { channelId: string; threadTs?: string };
+
+/** Inputs for the per-task context that rides in the task prompt. */
+export type TaskContextPromptArgs = Pick<
+  BasePromptArgs,
+  "role" | "traits" | "provider" | "scriptsOnly" | "serverCapabilities"
+> & {
+  repoContext?: RepoContext;
+  /** Slack context from the current task, if present */
+  slackContext?: SlackTaskContext;
+};
+
+function promptFlags(args: Pick<BasePromptArgs, "traits" | "provider" | "scriptsOnly">) {
   const {
     hasMcp = true,
     hasToolSearch = false,
     hasLocalEnvironment: hasLocalEnv = true,
     nativeSkillDiscovery = true,
-  } = traits ?? {};
+  } = args.traits ?? {};
+  const scriptsOnly = args.scriptsOnly ?? process.env.SCRIPTS_ONLY_MCP === "true";
+  return {
+    hasMcp,
+    hasToolSearch,
+    hasLocalEnv,
+    nativeSkillDiscovery,
+    provider: args.provider ?? "claude",
+    // Experimental scripts-only MCP surface (code-mode).
+    scriptsOnlyMode: hasMcp && scriptsOnly,
+  };
+}
+
+export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
+  const { role, agentId, traits } = args;
+  const { hasMcp, hasToolSearch, hasLocalEnv, nativeSkillDiscovery, provider, scriptsOnlyMode } =
+    promptFlags(args);
   const steerModes = traits?.steerModes ?? [];
-  const provider = args.provider ?? "claude";
 
   const defaultsInput = {
     name: args.name ?? agentId,
@@ -168,8 +212,6 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
 
   // Experimental scripts-only MCP surface (code-mode): named swarm tools are
   // not registered, so tell the agent everything goes through script-run.
-  const scriptsOnly = args.scriptsOnly ?? process.env.SCRIPTS_ONLY_MCP === "true";
-  const scriptsOnlyMode = hasMcp && scriptsOnly;
   if (scriptsOnlyMode) {
     const scriptsOnlyResult = await resolveTemplateAsync("system.agent.scripts_only_mode", {});
     prompt += `\n${scriptsOnlyResult.text}`;
@@ -199,13 +241,6 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
     const slackResult = await resolveTemplateAsync("system.agent.slack", {});
     prompt += slackResult.text;
   }
-  if (role !== "lead" && args.slackContext && scriptsOnlyMode && slackPromptToolsEnabled) {
-    const slackResult = await resolveTemplateAsync("system.agent.scripts_only_mode.slack", {
-      slackChannelId: args.slackContext.channelId,
-      slackThreadTs: args.slackContext.threadTs ?? "",
-    });
-    prompt += slackResult.text;
-  }
 
   if (
     hasMcp &&
@@ -244,9 +279,9 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
     prompt += toolsResult.text;
   }
 
-  // J. Agent notes (CLAUDE.md). Claude loads ~/.claude/CLAUDE.md natively and
-  // excludes the /workspace/CLAUDE.md copy (claude-flag-settings.ts); the others
-  // get it here, and only when it differs from the generated default.
+  // J. Agent notes (CLAUDE.md), only when it differs from the generated
+  // default. Claude excludes both ~/.claude/CLAUDE.md and /workspace/CLAUDE.md
+  // from its memory load (claude-flag-settings.ts), so this is its only copy.
   if (
     hasLocalEnv &&
     args.claudeMd &&
@@ -257,10 +292,42 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
       BOOTSTRAP_MAX_CHARS,
       Math.max(0, BOOTSTRAP_TOTAL_MAX_CHARS - prompt.length),
     );
-    prompt += truncateSection(args.claudeMd, "## Your notes (CLAUDE.md)", "CLAUDE.md", budget);
+    prompt += truncateSection(
+      args.claudeMd,
+      "## Your notes (CLAUDE.md)",
+      claudeMdSourcePath(provider),
+      budget,
+    );
   }
 
-  // K. Repository (per task). Never truncated except the inlined repo CLAUDE.md.
+  // Blocks start and end with a newline; collapse the seams to one blank line.
+  return prompt.replace(/\n{3,}/g, "\n\n");
+};
+
+/**
+ * Per-task context that used to close the system prompt: the repository block
+ * and the scripts-only Slack note. It rides in the task prompt so the system
+ * prompt stays byte-identical across an agent's sessions. Empty when the task
+ * has neither.
+ */
+export const getTaskContextPrompt = async (args: TaskContextPromptArgs): Promise<string> => {
+  const { hasMcp, hasLocalEnv, provider, scriptsOnlyMode } = promptFlags(args);
+  let prompt = "";
+
+  if (
+    args.role !== "lead" &&
+    args.slackContext &&
+    scriptsOnlyMode &&
+    areSlackPromptToolsEnabled(process.env, args.serverCapabilities)
+  ) {
+    const slackResult = await resolveTemplateAsync("system.agent.scripts_only_mode.slack", {
+      slackChannelId: args.slackContext.channelId,
+      slackThreadTs: args.slackContext.threadTs ?? "",
+    });
+    prompt += slackResult.text;
+  }
+
+  // Repository. Never truncated except the inlined repo CLAUDE.md.
   if (args.repoContext) {
     const repoResult = await resolveTemplateAsync(
       "system.agent.repository",
@@ -269,8 +336,7 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
     prompt += repoResult.text;
   }
 
-  // Blocks start and end with a newline; collapse the seams to one blank line.
-  return prompt.replace(/\n{3,}/g, "\n\n");
+  return prompt.replace(/\n{3,}/g, "\n\n").trim();
 };
 
 /**
@@ -331,7 +397,7 @@ function renderToolsAndSkillsVars(input: {
  * the heading lives in the template, the per-task pieces are built here.
  */
 function renderRepositoryVars(
-  repo: NonNullable<BasePromptArgs["repoContext"]>,
+  repo: RepoContext,
   ctx: { hasMcp: boolean; hasLocalEnv: boolean; provider: string },
 ): Record<string, string> {
   const vars: Record<string, string> = {
@@ -432,7 +498,7 @@ export function truncateRepoClaudeMd(content: string, clonePath: string, budget:
 function truncateSection(
   content: string | undefined,
   header: string,
-  fileName: string,
+  sourcePath: string,
   budget: number,
 ): string {
   if (!content || budget <= 0) return "";
@@ -441,7 +507,7 @@ function truncateSection(
   if (fullSection.length <= budget) return fullSection;
 
   const headerStr = `\n\n${header}\n\n`;
-  const notice = `\n\n[...truncated, see /workspace/${fileName} for full content]\n`;
+  const notice = `\n\n[...truncated, see ${sourcePath} for full content]\n`;
   const contentBudget = budget - headerStr.length - notice.length;
 
   if (contentBudget > 0) {

package/src/providers/acp-target-catalog.ts

@@ -1,3 +1,5 @@
+import { openAICompatibleBaseUrlVars, openAICompatibleKeyVars } from "@desplega/model-catalog";
+
 export const ACP_TARGET_IDS = [
   "opencode",
   "gemini",
@@ -40,6 +42,10 @@ export const ACP_TARGET_CATALOG: readonly AcpTargetCatalogEntry[] = [
       "OPENAI_API_KEY",
       "OPENROUTER_API_KEY",
       "OPENROUTER_BASE_URL",
+      // OpenAI-compatible registry providers: keys (canonical and alias),
+      // then their `<ID>_BASE_URL` overrides.
+      ...openAICompatibleKeyVars(),
+      ...openAICompatibleBaseUrlVars(),
       "GOOGLE_API_KEY",
       "GEMINI_API_KEY",
       "OPENCODE_CONFIG",

package/src/providers/acp-targets.ts

@@ -1,7 +1,12 @@
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { normalizeGrokModel } from "@desplega/model-catalog";
+import {
+  baseUrlOverride,
+  normalizeGrokModel,
+  providerBaseUrl,
+  providerForModel,
+} from "@desplega/model-catalog";
 import { clampContextPercent, getContextWindowSize } from "../utils/context-window";
 import {
   ACP_TARGET_IDS,
@@ -9,7 +14,11 @@ import {
   getAcpTargetCatalogEntry,
   isAcpTarget,
 } from "./acp-target-catalog";
-import { applyOpenRouterBaseUrlOverride, type OpencodeConfig } from "./opencode-adapter";
+import {
+  applyOpenRouterBaseUrlOverride,
+  buildOpenAICompatibleProviderBlock,
+  type OpencodeConfig,
+} from "./opencode-adapter";
 import { applyReasoningEffort } from "./reasoning-effort";
 import type { CostData, CostModelUsage, ProviderEvent, ProviderSessionConfig } from "./types";
 
@@ -140,10 +149,54 @@ function withOpencodeConfig(env: Record<string, string>, model: string): void {
     }
   }
   if (model.trim()) value.model = model.trim();
+  withCustomProviderBlock(value as OpencodeConfig, model.trim(), env);
   applyOpenRouterBaseUrlOverride(value as OpencodeConfig, env);
   env[key] = JSON.stringify(value);
 }
 
+/**
+ * OpenCode ships no provider for a registry entry models.dev does not list
+ * (`catalog: "registry"`, e.g. `helmcode`), so its models need the custom
+ * block. The key stays an `{env:…}` reference: the ACP subprocess env is the
+ * forwarded per-task env, where the var holds one picked key, so no literal
+ * key lands in `OPENCODE_CONFIG_CONTENT`. A built-in registry provider
+ * (`nan`) only gets `options.baseURL` when `<ID>_BASE_URL` is set. Values the
+ * operator already set in `OPENCODE_CONFIG_CONTENT` win over the defaults.
+ */
+function withCustomProviderBlock(
+  config: OpencodeConfig,
+  model: string,
+  env: Record<string, string>,
+): void {
+  const provider = providerForModel(model);
+  if (!provider) return;
+  const existing = config.provider?.[provider.id];
+  if (provider.catalog !== "registry") {
+    const baseURL = baseUrlOverride(provider, env);
+    if (!baseURL) return;
+    config.provider = {
+      ...config.provider,
+      [provider.id]: { ...existing, options: { baseURL, ...existing?.options } },
+    };
+    return;
+  }
+  const block = buildOpenAICompatibleProviderBlock(
+    provider,
+    `{env:${provider.envVar}}`,
+    model.slice(provider.id.length + 1),
+    providerBaseUrl(provider, env),
+  );
+  config.provider = {
+    ...config.provider,
+    [provider.id]: {
+      ...block,
+      ...existing,
+      options: { ...block.options, ...existing?.options },
+      models: { ...block.models, ...existing?.models },
+    },
+  };
+}
+
 function parseCommand(command: string, args: string | undefined): string[] {
   const trimmed = command.trim();
   if (!trimmed) {
@@ -306,7 +359,7 @@ const copilotTargetProfile: AcpTargetProfile = {
   },
 };
 
-/** Qwen Code's `--auth-type` choices (0.25.1). `qwen-oauth` needs a browser, so it is left out. */
+/** Qwen Code's `--auth-type` choices (0.25.2). `qwen-oauth` needs a browser, so it is left out. */
 const QWEN_AUTH_TYPES = ["openai", "openai-responses", "anthropic", "gemini", "vertex-ai"] as const;
 
 // Qwen Code is a Gemini CLI fork: QWEN_SYSTEM_MD replaces its built-in prompt

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1791979242-g144271";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792152053-g57ff9b";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/claude-adapter.ts

@@ -1041,7 +1041,7 @@ class ClaudeSession implements ProviderSession {
       "--allow-dangerously-skip-permissions",
       "--permission-mode",
       "bypassPermissions",
-      // Skip the workspace copy of claudeMd; ~/.claude/CLAUDE.md already carries it.
+      // Skip both on-disk copies of claudeMd; the system prompt already carries it.
       // createSession merged caller `--settings` into these, so this is the only one.
       "--settings",
       JSON.stringify(this.flagSettings),

package/src/providers/claude-flag-settings.ts

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
 /**
@@ -9,17 +10,28 @@ import { scrubSecrets } from "../utils/secret-scrubber";
  * and it walks up from its cwd (`/workspace/...`) to load `/workspace/CLAUDE.md`
  * as project memory too, so every Claude session paid for the notes twice.
  *
- * `claudeMdExcludes` drops only that one path from Claude's memory load. The
- * file stays on disk for the other harnesses (one container can live-swap
- * providers mid-run), and repo-level `CLAUDE.md` files still load.
+ * `claudeMdExcludes` drops that path from Claude's memory load. The file stays
+ * on disk for the other harnesses (one container can live-swap providers
+ * mid-run), and repo-level `CLAUDE.md` files still load.
+ *
+ * The user-memory copy (`~/.claude/CLAUDE.md`) is excluded too: the system
+ * prompt carries the same notes (base-prompt.ts block J), where the provider
+ * caches them across sessions. Claude would load the user-memory copy into an
+ * uncached message instead. The SessionStart hook still writes that file: it
+ * is the copy the agent edits and the Stop hook syncs back to the profile.
  */
 export const WORKSPACE_CLAUDE_MD_EXCLUDE = "/workspace/CLAUDE.md";
 
+/** `~/.claude/CLAUDE.md` for the HOME the Claude session runs under. */
+export function userClaudeMdExclude(home: string = process.env.HOME ?? homedir()): string {
+  return join(home, ".claude", "CLAUDE.md");
+}
+
 export type ClaudeFlagSettings = Record<string, unknown> & { claudeMdExcludes: string[] };
 
 /** Flag-level settings (`--settings` / SDK `settings`) for every Claude session. */
 export function claudeFlagSettings(): ClaudeFlagSettings {
-  return { claudeMdExcludes: [WORKSPACE_CLAUDE_MD_EXCLUDE] };
+  return { claudeMdExcludes: [WORKSPACE_CLAUDE_MD_EXCLUDE, userClaudeMdExclude()] };
 }
 
 const SETTINGS_FLAG = "--settings";

package/src/providers/claude-managed-adapter.ts

@@ -806,7 +806,7 @@ class ClaudeManagedSession implements ProviderSession {
 export class ClaudeManagedAdapter implements ProviderAdapter {
   readonly name = "claude-managed";
   // Anthropic's cloud sandbox calls back into our /mcp endpoint, but the worker
-  // process is a thin SSE relay — no /workspace, no PM2, no agent-fs, no skills FS.
+  // process is a thin SSE relay — no /workspace, no agent-fs, no skills FS.
   readonly traits: ProviderTraits = {
     hasMcp: true,
     hasToolSearch: false,

package/src/providers/claude-session-events.ts

@@ -32,6 +32,7 @@ type ClaudeUsage = {
   cache_read_input_tokens?: number;
   cache_creation_input_tokens?: number;
   thinking_input_tokens?: number;
+  output_tokens_details?: { thinking_tokens?: number };
   cache_creation?: Record<string, unknown>;
 };
 
@@ -125,7 +126,11 @@ function costFromResult(
     cacheWriteTokens: usage?.cache_creation_input_tokens ?? 0,
     cacheWrite5mTokens: finiteNumber(cacheCreation?.ephemeral_5m_input_tokens),
     cacheWrite1hTokens: finiteNumber(cacheCreation?.ephemeral_1h_input_tokens),
-    thinkingTokens: usage?.thinking_input_tokens ?? 0,
+    // A subset of output_tokens, already billed at the output rate.
+    thinkingTokens:
+      tokenCount(usage?.output_tokens_details?.thinking_tokens) ??
+      tokenCount(usage?.thinking_input_tokens) ??
+      0,
     models,
     durationMs: json.duration_ms || 0,
     numTurns: json.num_turns ?? null,

package/src/providers/dsh-adapter.ts

@@ -37,7 +37,7 @@ import type {
 } from "./types";
 
 // npm's `latest` is older and lacks the JSON/stdin contract used here.
-export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-alpha.3";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-alpha.5";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()