@desplega.ai/agent-swarm 1.172.0 → 2.0.0

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.1791878731-g2f7fd0";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792065649-g5a30fc";
 
 /** 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

@@ -42,6 +42,11 @@ import {
 } from "../utils/process-group";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { ClaudeBackgroundKeepalive } from "./claude-background-keepalive";
+import {
+  type ClaudeFlagSettings,
+  claudeFlagSettings,
+  mergeClaudeSettingsArgs,
+} from "./claude-flag-settings";
 import { normalizeClaudeMessage } from "./claude-session-events";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
@@ -923,6 +928,8 @@ class ClaudeSession implements ProviderSession {
     private readonly runSessionSummary: (
       opts: RunStopHookSessionSummaryOpts,
     ) => Promise<void> = runStopHookSessionSummarySubprocess,
+    /** Validated session settings; `createSession` already merged caller `--settings` into them. */
+    private readonly flagSettings: ClaudeFlagSettings = claudeFlagSettings(),
   ) {
     this.taskFileKey = taskFileKey;
     this.contextWindowSize = getContextWindowSize(model);
@@ -1034,6 +1041,10 @@ class ClaudeSession implements ProviderSession {
       "--allow-dangerously-skip-permissions",
       "--permission-mode",
       "bypassPermissions",
+      // 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),
     ];
 
     // Queued steering needs `--input-format stream-json`, which is mutually
@@ -1360,9 +1371,20 @@ export class ClaudeAdapter implements ProviderAdapter {
       );
     }
     const isLegacyBridgeCompat = isLegacyClaudeBridgeCompatBinary(claudeBinaryRaw);
-    const effectiveClaudeBinaryArgv = useClaudeBridge
+    const [claudeExecutable = "claude", ...claudePrefixArgs] = useClaudeBridge
       ? withClaudeBridgeAuthArgs(claudeBinaryArgv, sourceEnv)
       : claudeBinaryArgv;
+    // Validate and merge caller `--settings` (CLAUDE_BINARY prefix and
+    // additionalArgs) once, before any log, write, or Claude spawn. An unusable
+    // value throws here, so nothing below runs. Every spawn (the version probe
+    // and the session) then gets the stripped argv plus this one settings value.
+    const {
+      argLists: [prefixArgs = [], additionalArgs = []],
+      settings: flagSettings,
+    } = mergeClaudeSettingsArgs([claudePrefixArgs, config.additionalArgs ?? []], config.cwd);
+    const effectiveClaudeBinaryArgv = [claudeExecutable, ...prefixArgs];
+    sessionConfig.additionalArgs = additionalArgs;
+    const flagSettingsArgs = ["--settings", JSON.stringify(flagSettings)];
     const isInteractiveTmuxClaude = isLegacyBridgeCompat || useClaudeBridge;
     const configuredClaudeBinaryRaw = resolveClaudeBinary(sourceEnv);
     if (isLegacyClaudeBridgeCompatBinary(configuredClaudeBinaryRaw)) {
@@ -1371,6 +1393,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       );
     }
 
+    // Caller settings are already stripped from this argv; never log their contents.
     console.log(
       `\x1b[2m[${config.role}]\x1b[0m Resolved claude binary: ${effectiveClaudeBinaryArgv.join(" ")} (useClaudeBridge: ${useClaudeBridge}, legacyBridgeCompat: ${isLegacyBridgeCompat})`,
     );
@@ -1456,7 +1479,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     let harnessVersion: string | undefined;
     try {
       const probe = registerProcessGroup(
-        Bun.spawn([...effectiveClaudeBinaryArgv, "--version"], {
+        Bun.spawn([...effectiveClaudeBinaryArgv, ...flagSettingsArgs, "--version"], {
           detached: detachedProcessGroup,
           env: sourceEnv,
           stdin: "ignore",
@@ -1504,6 +1527,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         taskFileKey,
         sessionMcpConfig,
         claudeBinaryArgv: effectiveClaudeBinaryArgv,
+        settings: flagSettings,
         systemPromptFile,
         harnessVariant,
         harnessVariantMeta,
@@ -1524,6 +1548,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       harnessVariantMeta,
       queueSteeringSupported,
       this.runSessionSummary,
+      flagSettings,
     );
   }
 

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

@@ -0,0 +1,133 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { scrubSecrets } from "../utils/secret-scrubber";
+
+/**
+ * The runner writes the agent's `claudeMd` to `/workspace/CLAUDE.md` for the
+ * non-Claude harnesses (codex/opencode/pi read and edit it there). Claude Code
+ * already gets the same content as user memory from `~/.claude/CLAUDE.md`,
+ * 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 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, userClaudeMdExclude()] };
+}
+
+const SETTINGS_FLAG = "--settings";
+
+/**
+ * Explicit caller `--settings` that cannot be used. The session refuses to
+ * start: launching without them would drop the caller's sandbox rules and
+ * blocking hooks while still running with bypassPermissions. The message is
+ * scrubbed and never echoes inline JSON.
+ */
+export class ClaudeSettingsConfigError extends Error {
+  constructor(detail: string) {
+    super(
+      scrubSecrets(
+        `Invalid caller --settings: ${detail}. Refusing to start Claude without the caller's settings.`,
+      ),
+    );
+    this.name = "ClaudeSettingsConfigError";
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Parses one caller `--settings` value the way Claude Code reads it: inline
+ * JSON when it starts with `{`, otherwise a settings file path (relative paths
+ * resolve against the session cwd). Throws ClaudeSettingsConfigError when the
+ * value cannot be used.
+ */
+function parseCallerSettings(value: string, cwd: string): Record<string, unknown> {
+  const inline = value.trimStart().startsWith("{");
+  const source = inline ? "inline JSON" : `file ${resolve(cwd, value)}`;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(inline ? value : readFileSync(resolve(cwd, value), "utf8"));
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    throw new ClaudeSettingsConfigError(
+      `${source} ${inline || !code ? "is not valid JSON" : `cannot be read (${code})`}`,
+    );
+  }
+  if (!isPlainObject(parsed)) {
+    throw new ClaudeSettingsConfigError(`${source} is not a JSON object`);
+  }
+  return parsed;
+}
+
+/**
+ * Removes every `--settings <v>` / `--settings=<v>` from each caller argv list
+ * (CLAUDE_BINARY prefix args, additionalArgs) and folds those values into the
+ * session's own flag settings, so the spawned Claude sees exactly one settings
+ * value. Caller keys are kept (later values win); `claudeMdExcludes` becomes
+ * the deduped union of the caller lists and the workspace exclusion.
+ *
+ * Fails closed: a missing value (end of argv, or a next token that is another
+ * flag) or an unreadable, invalid or non-object value throws
+ * ClaudeSettingsConfigError instead of starting without the caller's settings.
+ */
+export function mergeClaudeSettingsArgs(
+  argLists: readonly (readonly string[])[],
+  cwd: string,
+): { argLists: string[][]; settings: ClaudeFlagSettings } {
+  const merged: Record<string, unknown> = {};
+  const excludes = new Set<string>();
+
+  const absorb = (value: string | undefined) => {
+    if (!value) throw new ClaudeSettingsConfigError("--settings has no value");
+    const parsed = parseCallerSettings(value, cwd);
+    Object.assign(merged, parsed);
+    if (Array.isArray(parsed.claudeMdExcludes)) {
+      for (const entry of parsed.claudeMdExcludes) {
+        if (typeof entry === "string") excludes.add(entry);
+      }
+    }
+  };
+
+  const stripped = argLists.map((args) => {
+    const passthrough: string[] = [];
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i] ?? "";
+      if (arg === SETTINGS_FLAG) {
+        const value = args[i + 1];
+        // Never consume the next flag (`--max-turns`, `--settings=...`) as the value.
+        absorb(value?.startsWith("-") ? undefined : value);
+        i++;
+      } else if (arg.startsWith(`${SETTINGS_FLAG}=`)) {
+        absorb(arg.slice(SETTINGS_FLAG.length + 1));
+      } else {
+        passthrough.push(arg);
+      }
+    }
+    return passthrough;
+  });
+
+  for (const entry of claudeFlagSettings().claudeMdExcludes) excludes.add(entry);
+  return { argLists: stripped, settings: { ...merged, claudeMdExcludes: [...excludes] } };
+}

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-sdk-session.ts

@@ -30,6 +30,7 @@ import {
   runClaudeSessionSummary,
 } from "./claude-adapter";
 import { ClaudeBackgroundKeepalive } from "./claude-background-keepalive";
+import type { ClaudeFlagSettings } from "./claude-flag-settings";
 import type { ClaudeProtocolMessage } from "./claude-session-events";
 import { normalizeClaudeMessage } from "./claude-session-events";
 import type {
@@ -281,7 +282,10 @@ export type CreateClaudeSdkSessionOptions = {
   taskFilePath: string;
   taskFileKey: string;
   sessionMcpConfig: string | null;
+  /** Claude argv prefix with caller `--settings` already stripped. */
   claudeBinaryArgv: readonly string[];
+  /** Validated session settings, caller `--settings` merged in. */
+  settings: ClaudeFlagSettings;
   systemPromptFile: string | null;
   harnessVariant?: string;
   harnessVariantMeta?: Record<string, unknown>;
@@ -470,6 +474,9 @@ class ClaudeSdkSession implements ProviderSession {
           pathToClaudeCodeExecutable: executable,
           systemPrompt: { type: "preset", preset: "claude_code" },
           settingSources: ["user", "project", "local"],
+          // createSession merged caller `--settings` into these; the SDK passes
+          // them as the spawned Claude's one `--settings` flag.
+          settings: this.options.settings,
           permissionMode: "bypassPermissions",
           allowDangerouslySkipPermissions: true,
           stderr: (text) => {

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.2";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-alpha.4";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()