@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/tools/tool-config.ts

@@ -154,6 +154,13 @@ export const DEFERRED_TOOLS = new Set([
   "kv-incr",
   "kv-list",
 
+  // Reusable scripts (5)
+  "script-search",
+  "script-run",
+  "script-upsert",
+  "script-delete",
+  "script-query-types",
+
   // Other (3)
   "cancel-task",
   "inject-learning",

package/src/tools/utils.ts

@@ -12,6 +12,8 @@ import type {
   ServerRequest,
   ToolAnnotations,
 } from "@modelcontextprotocol/sdk/types.js";
+import { withSpan } from "../otel";
+import { scrubSecrets } from "../utils/secret-scrubber";
 
 type Meta = RequestHandlerExtra<ServerRequest, ServerNotification>;
 
@@ -46,6 +48,38 @@ export const getRequestInfo = (req: Meta): RequestInfo => {
   };
 };
 
+const PREVIEW_LIMIT = 500;
+
+function previewValue(value: unknown): string | undefined {
+  if (value === undefined) return undefined;
+  try {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (!serialized) return undefined;
+    const scrubbed = scrubSecrets(serialized);
+    return scrubbed.length > PREVIEW_LIMIT ? `${scrubbed.slice(0, PREVIEW_LIMIT)}...` : scrubbed;
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+function toolRequestAttributes(name: string, requestInfo: RequestInfo, args?: unknown) {
+  return {
+    "mcp.tool.name": name,
+    "mcp.session.id": requestInfo.sessionId,
+    "agent.id": requestInfo.agentId,
+    "agentswarm.task.id": requestInfo.sourceTaskId,
+    "agentswarm.tool.args_preview": previewValue(args),
+  };
+}
+
+function toolResultAttributes(result: CallToolResult) {
+  return {
+    "mcp.tool.result_content_count": Array.isArray(result.content) ? result.content.length : 0,
+    "mcp.tool.is_error": result.isError ?? false,
+    "agentswarm.tool.result_preview": previewValue(result.content),
+  };
+}
+
 // Infer the input type from the schema
 type InferInput<Args extends undefined | ZodRawShapeCompat | AnySchema> =
   Args extends ZodRawShapeCompat
@@ -104,23 +138,42 @@ export const createToolRegistrar = (server: McpServer) => {
     // When inputSchema is undefined, the MCP SDK calls handler(extra) with a single arg.
     // When inputSchema is defined, it calls handler(args, extra) with two args.
     if (config.inputSchema === undefined) {
-      return server.registerTool(name, config, ((meta: Meta) => {
+      return server.registerTool(name, config, (async (meta: Meta) => {
         const requestInfo = getRequestInfo(meta);
-        return (
-          cb as (requestInfo: RequestInfo, meta: Meta) => CallToolResult | Promise<CallToolResult>
-        )(requestInfo, meta);
+        return withSpan(
+          "mcp.tool",
+          async (span) => {
+            const result = await (
+              cb as (
+                requestInfo: RequestInfo,
+                meta: Meta,
+              ) => CallToolResult | Promise<CallToolResult>
+            )(requestInfo, meta);
+            span.setAttributes(toolResultAttributes(result));
+            return result;
+          },
+          toolRequestAttributes(name, requestInfo),
+        );
       }) as Parameters<typeof server.registerTool>[2]);
     }
 
-    return server.registerTool(name, config, ((args: InferInput<InputArgs>, meta: Meta) => {
+    return server.registerTool(name, config, (async (args: InferInput<InputArgs>, meta: Meta) => {
       const requestInfo = getRequestInfo(meta);
-      return (
-        cb as (
-          args: InferInput<InputArgs>,
-          requestInfo: RequestInfo,
-          meta: Meta,
-        ) => CallToolResult | Promise<CallToolResult>
-      )(args, requestInfo, meta);
+      return withSpan(
+        "mcp.tool",
+        async (span) => {
+          const result = await (
+            cb as (
+              args: InferInput<InputArgs>,
+              requestInfo: RequestInfo,
+              meta: Meta,
+            ) => CallToolResult | Promise<CallToolResult>
+          )(args, requestInfo, meta);
+          span.setAttributes(toolResultAttributes(result));
+          return result;
+        },
+        toolRequestAttributes(name, requestInfo, args),
+      );
     }) as Parameters<typeof server.registerTool>[2]);
   };
 };

package/src/types.ts

@@ -192,7 +192,10 @@ export const AgentTaskSchema = z.object({
   // Context usage aggregates
   compactionCount: z.number().int().min(0).optional(),
   peakContextPercent: z.number().min(0).max(100).optional(),
-  totalContextTokensUsed: z.number().int().min(0).optional(),
+  // Migration 063: renamed from totalContextTokensUsed. Semantic is now a
+  // monotonic max across the task's snapshots — "high water mark" rather than
+  // "latest known".
+  peakContextTokens: z.number().int().min(0).optional(),
   contextWindowSize: z.number().int().min(0).optional(),
 
   // Credential tracking
@@ -574,7 +577,9 @@ export const SessionLogSchema = z.object({
 export type SessionLog = z.infer<typeof SessionLogSchema>;
 
 // Session Cost Types (aggregated cost data per session)
-export const SessionCostSourceSchema = z.enum(["harness", "pricing-table"]);
+// Migration 063 widened the set to include 'unpriced' for cases where the API
+// recompute path couldn't find pricing rows for the (provider, model, token_class).
+export const SessionCostSourceSchema = z.enum(["harness", "pricing-table", "unpriced"]);
 export type SessionCostSource = z.infer<typeof SessionCostSourceSchema>;
 
 export const SessionCostSchema = z.object({
@@ -587,13 +592,22 @@ export const SessionCostSchema = z.object({
   outputTokens: z.number().int().min(0).default(0),
   cacheReadTokens: z.number().int().min(0).default(0),
   cacheWriteTokens: z.number().int().min(0).default(0),
+  // Migration 063: reasoning_output_tokens from codex turn.completed events.
+  reasoningOutputTokens: z.number().int().min(0).default(0),
+  // Migration 063: thinking_input_tokens from claude extended-thinking flows.
+  thinkingTokens: z.number().int().min(0).default(0),
   durationMs: z.number().int().min(0),
-  numTurns: z.number().int().min(1),
+  // numTurns is nullable — some adapters (e.g. Claude when num_turns is absent)
+  // can't honestly report a turn count. We prefer null over a faked 1.
+  numTurns: z.number().int().min(1).nullable(),
   model: z.string(),
   isError: z.boolean().default(false),
-  // Phase 6: where the recorded totalCostUsd came from. New rows write the
-  // actual source ('pricing-table' when the API recomputed Codex USD from DB
-  // pricing rows, 'harness' otherwise). Defaults to 'harness' for back-compat.
+  // Phase 6 (extended by migration 063): where the recorded totalCostUsd came from.
+  //   'harness'        — value reported by the harness as-is.
+  //   'pricing-table'  — value recomputed by the API from `pricing` rows.
+  //   'unpriced'       — the API tried to recompute but the (provider, model)
+  //                      had no matching pricing rows; totalCostUsd is whatever
+  //                      the worker submitted (often 0).
   costSource: SessionCostSourceSchema.default("harness"),
   createdAt: z.iso.datetime(),
 });
@@ -646,6 +660,8 @@ export const EventNameSchema = z.enum([
   "system.boot",
   "system.migration",
   "system.error",
+  // Script catalog events
+  "script.global_upsert",
 ]);
 
 export const SwarmEventSchema = z.object({
@@ -862,18 +878,30 @@ export const StepValidationConfigSchema = z.object({
 });
 export type StepValidationConfig = z.infer<typeof StepValidationConfigSchema>;
 
+export const SwarmScriptNodeConfigSchema = z.object({
+  scriptName: z.string().min(1),
+  scope: z.enum(["global", "agent"]).optional(),
+  pinHash: z.string().min(1).optional(),
+  args: z.record(z.string(), z.unknown()).optional(),
+  fsMode: z.enum(["none", "workspace-rw"]).optional(),
+});
+export type SwarmScriptNodeConfig = z.infer<typeof SwarmScriptNodeConfigSchema>;
+
 // --- Workflow Node (nodes-with-next) ---
 
 export const WorkflowNodeSchema = z.object({
   id: z.string().describe("Unique node identifier, used in 'next' and 'inputs' mappings"),
   type: z
     .string()
-    .describe("Executor type: 'agent-task', 'script', 'raw-llm', 'validate', 'property-match'"),
+    .describe(
+      "Executor type: 'agent-task', 'script', 'swarm-script', 'raw-llm', 'validate', 'property-match'",
+    ),
   label: z.string().optional().describe("Human-readable label for UI display"),
   config: z
     .record(z.string(), z.unknown())
     .describe(
       "Executor-specific config. For agent-task: { template, outputSchema?, agentId?, tags?, priority?, dir?, vcsRepo?, model? }. " +
+        "For swarm-script: { scriptName, scope?, pinHash?, args?, fsMode? }. " +
         "Values support {{interpolation}} from the node's inputs context. " +
         "NOTE: config.outputSchema on agent-task nodes validates the AGENT's raw JSON output, " +
         "while node-level outputSchema validates the EXECUTOR's return value ({taskId, taskOutput}).",
@@ -1273,6 +1301,51 @@ export const PromptTemplateHistorySchema = z.object({
 });
 export type PromptTemplateHistory = z.infer<typeof PromptTemplateHistorySchema>;
 
+// ============================================================================
+// Script Types
+// ============================================================================
+
+export const ScriptScopeSchema = z.enum(["global", "agent"]);
+export type ScriptScope = z.infer<typeof ScriptScopeSchema>;
+
+export const ScriptFsModeSchema = z.enum(["none", "workspace-rw"]);
+export type ScriptFsMode = z.infer<typeof ScriptFsModeSchema>;
+
+export const ScriptRecordSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  scope: ScriptScopeSchema,
+  scopeId: z.string().nullable(),
+  source: z.string(),
+  description: z.string(),
+  intent: z.string(),
+  signatureJson: z.string(),
+  contentHash: z.string(),
+  version: z.number(),
+  isScratch: z.boolean(),
+  typeChecked: z.boolean(),
+  fsMode: ScriptFsModeSchema,
+  createdByAgentId: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type ScriptRecord = z.infer<typeof ScriptRecordSchema>;
+
+export const ScriptVersionRecordSchema = z.object({
+  id: z.string(),
+  scriptId: z.string(),
+  version: z.number(),
+  source: z.string(),
+  description: z.string(),
+  intent: z.string(),
+  signatureJson: z.string(),
+  contentHash: z.string(),
+  changedByAgentId: z.string().nullable(),
+  changedAt: z.string(),
+  changeReason: z.string().nullable(),
+});
+export type ScriptVersionRecord = z.infer<typeof ScriptVersionRecordSchema>;
+
 // ============================================================================
 // Skill Types
 // ============================================================================
@@ -1381,6 +1454,21 @@ export type McpServerWithInstallInfo = z.infer<typeof McpServerWithInstallInfoSc
 export const ContextSnapshotEventTypeSchema = z.enum(["progress", "compaction", "completion"]);
 export type ContextSnapshotEventType = z.infer<typeof ContextSnapshotEventTypeSchema>;
 
+// Migration 063: the formula the emitting adapter used to compute
+// contextUsedTokens. Lets downstream consumers (UI badges, cross-provider
+// comparisons) reason about whether two numbers are commensurable. Values
+// match the inline doc in `src/be/migrations/063_cost_context_schema_relax.sql`.
+export const ContextFormulaSchema = z.enum([
+  "input-cache-output", // unified formula (post-Phase 9)
+  "input-cache-no-output", // pre-unification claude formula
+  "input-output-no-cache", // pre-unification claude-managed formula
+  "peak-proxy", // pre-unification codex formula
+  "pi-delegated", // numbers come from the pi-ai SDK
+  "harness-reported", // numbers come from a harness API (devin)
+  "unknown", // pre-migration backfill or adapter didn't tag
+]);
+export type ContextFormula = z.infer<typeof ContextFormulaSchema>;
+
 export const ContextSnapshotSchema = z.object({
   id: z.uuid(),
   taskId: z.uuid(),
@@ -1396,13 +1484,18 @@ export const ContextSnapshotSchema = z.object({
   eventType: ContextSnapshotEventTypeSchema,
 
   // Compaction-specific (null for non-compaction)
-  compactTrigger: z.enum(["auto", "manual"]).optional(),
+  compactTrigger: z.enum(["auto", "manual", "auto-inferred"]).optional(),
   preCompactTokens: z.number().int().min(0).optional(),
 
   // Cumulative counters at this point
   cumulativeInputTokens: z.number().int().min(0).default(0),
   cumulativeOutputTokens: z.number().int().min(0).default(0),
 
+  // Migration 063 — adapter stamps the formula it used to compute
+  // contextUsedTokens. Optional so old rows / new providers without a tag
+  // don't break, but every adapter should populate this going forward.
+  contextFormula: ContextFormulaSchema.optional(),
+
   createdAt: z.iso.datetime(),
 });
 
@@ -1430,10 +1523,29 @@ export const BudgetSchema = z.object({
 });
 export type Budget = z.infer<typeof BudgetSchema>;
 
-export const PricingProviderSchema = z.enum(["claude", "codex", "pi"]);
+// Migration 063 widened both enums and dropped the SQL CHECKs to match.
+// New providers can land without an accompanying schema migration; Zod is now
+// the single source of truth for what's a valid (provider, token_class) row.
+export const PricingProviderSchema = z.enum([
+  "claude",
+  "claude-managed",
+  "codex",
+  "pi",
+  "opencode",
+  "devin",
+  "gemini",
+]);
 export type PricingProvider = z.infer<typeof PricingProviderSchema>;
 
-export const PricingTokenClassSchema = z.enum(["input", "cached_input", "output"]);
+export const PricingTokenClassSchema = z.enum([
+  "input",
+  "cached_input",
+  "output",
+  // Migration 063 additions:
+  "cache_write", // claude / claude-managed cache creation
+  "runtime_hour", // claude-managed runtime fee per hour
+  "acu", // devin Agent Compute Unit
+]);
 export type PricingTokenClass = z.infer<typeof PricingTokenClassSchema>;
 
 export const PricingRowSchema = z.object({

package/src/utils/api-key.ts

@@ -0,0 +1,28 @@
+/**
+ * Centralized resolution of the swarm API key from the environment.
+ *
+ * Precedence:
+ *   1. AGENT_SWARM_API_KEY  (preferred — namespaced, safe to set globally)
+ *   2. API_KEY              (legacy — kept for back-compat with existing setups)
+ *
+ * All swarm code (CLI, server, hooks, worker, scripts) must read the key via
+ * `getApiKey()` so a user can configure either env var and have it work end
+ * to end. Direct access to `process.env.API_KEY` / `process.env.AGENT_SWARM_API_KEY`
+ * outside this module is enforced against by `scripts/check-api-key-boundary.sh`.
+ */
+
+type EnvLike = Record<string, string | undefined>;
+
+export function getApiKey(env: EnvLike = process.env): string {
+  return env.AGENT_SWARM_API_KEY ?? env.API_KEY ?? "";
+}
+
+/**
+ * Mirror a resolved key onto both env var names so any downstream code that
+ * still reads the raw env (third-party libraries, spawned subprocesses that
+ * inherit env, etc.) sees a consistent value.
+ */
+export function setApiKey(key: string, env: EnvLike = process.env): void {
+  env.AGENT_SWARM_API_KEY = key;
+  env.API_KEY = key;
+}

package/src/utils/context-window.ts

@@ -2,31 +2,95 @@
  * Context window size lookup and usage computation utilities.
  *
  * This module is safe for both API and worker code — it has NO database imports.
+ *
+ * Phase 4 + Phase 9 of the cost-tracking plan:
+ *   - `getContextWindowSize` now resolves shortnames, family-versioned ids
+ *     (`claude-sonnet-4-6`), AND dated full ids (`claude-sonnet-4-6-20251004`)
+ *     by stripping the trailing date suffix. Previously the dated form fell
+ *     to the 200k default — wildly wrong for sonnet/opus 4.x.
+ *   - `computeContextUsedUnified` is the canonical formula every adapter
+ *     should use when emitting a `context_usage` event:
+ *       contextUsedTokens = input + cache_read + cache_create + output
+ *     The matching `CONTEXT_FORMULA` constant is what adapters stamp onto
+ *     the snapshot's `contextFormula` field.
+ *   - The legacy `computeContextUsed` stays for back-compat reads but is
+ *     deprecated; new code should use `computeContextUsedUnified`.
+ */
+
+/**
+ * Phase 9: stamp this onto every `context_usage` event the adapter emits.
+ * Callers that compute their own number for legacy reasons (e.g. pi-mono
+ * delegates to the pi-ai SDK) use a different value — see `ContextFormula`
+ * in `src/types.ts`.
  */
+export const CONTEXT_FORMULA = "input-cache-output" as const;
 
 const CONTEXT_WINDOW_DEFAULTS: Record<string, number> = {
+  // Anthropic 4.x family
+  "claude-opus-4-7": 1_000_000,
   "claude-opus-4-6": 1_000_000,
+  "claude-opus-4-5": 1_000_000,
+  "claude-opus-4-1": 200_000,
+  "claude-opus-4-0": 200_000,
   "claude-sonnet-4-6": 1_000_000,
+  "claude-sonnet-4-5": 1_000_000,
+  "claude-sonnet-4-0": 200_000,
   "claude-haiku-4-5": 200_000,
+  // Anthropic 3.x family (legacy)
+  "claude-3-7-sonnet": 200_000,
+  "claude-3-5-sonnet": 200_000,
+  "claude-3-5-haiku": 200_000,
+  "claude-3-opus": 200_000,
+  "claude-3-sonnet": 200_000,
+  "claude-3-haiku": 200_000,
+  // Shortnames used by the local-CLI adapter and pi-mono OpenRouter mirror.
   opus: 1_000_000,
   sonnet: 1_000_000,
   haiku: 200_000,
   default: 200_000,
 };
 
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+
 /**
- * Look up the context window size (in tokens) for a given model identifier.
- * Falls back to the "default" entry when the model is not explicitly mapped.
+ * Strip a trailing date suffix from a Claude model id so dated full ids
+ * resolve to the same window as the family-versioned id.
+ *
+ * `claude-sonnet-4-6-20251004` → `claude-sonnet-4-6`
+ * `claude-haiku-4-5-20251001`  → `claude-haiku-4-5`
+ *
+ * Anthropic's dated full ids are always `${family}-${major}-${minor}-${YYYYMMDD}`,
+ * so an 8-digit trailing date is a reliable signal.
  */
-const DEFAULT_CONTEXT_WINDOW = 200_000;
+function stripAnthropicDateSuffix(model: string): string {
+  return model.replace(/-(\d{8})$/, "");
+}
 
 export function getContextWindowSize(model: string): number {
-  return CONTEXT_WINDOW_DEFAULTS[model] ?? DEFAULT_CONTEXT_WINDOW;
+  // Fast path: exact match (shortname or family-versioned id).
+  if (CONTEXT_WINDOW_DEFAULTS[model] !== undefined) {
+    return CONTEXT_WINDOW_DEFAULTS[model];
+  }
+  // Dated full id → strip suffix and retry.
+  const stripped = stripAnthropicDateSuffix(model);
+  if (stripped !== model && CONTEXT_WINDOW_DEFAULTS[stripped] !== undefined) {
+    return CONTEXT_WINDOW_DEFAULTS[stripped];
+  }
+  // OpenAI / GPT family — most reasoning models have 200k+; we keep this
+  // conservative and let callers override via models.dev rates if they want.
+  // Specific gpt-5.x context windows are >1M but the local-CLI adapter
+  // generally doesn't surface those; the API recompute path uses the rate
+  // table, not the window. The 200k default keeps the math safe.
+  return DEFAULT_CONTEXT_WINDOW;
 }
 
 /**
  * Compute the total context tokens used from a Claude API usage object.
  * Sums input_tokens + cache_creation_input_tokens + cache_read_input_tokens.
+ *
+ * @deprecated Phase 9 — use {@link computeContextUsedUnified} instead. This
+ * variant excludes output tokens, which is the wrong number when the goal is
+ * "how full is the model's context window right now."
  */
 export function computeContextUsed(usage: {
   input_tokens?: number | null;
@@ -39,3 +103,39 @@ export function computeContextUsed(usage: {
     (usage.cache_read_input_tokens ?? 0)
   );
 }
+
+/**
+ * Phase 9: the unified context-used formula adapters should use when emitting
+ * `context_usage` events. Sums input + cache_read + cache_create + output,
+ * which is the number the Claude Code status line shows. Cross-provider
+ * comparisons (claude vs codex vs pi) are only meaningful when every adapter
+ * agrees on this formula.
+ *
+ * Returns 0 if every field is missing; callers should check the `contextTotal`
+ * separately and emit `null` for `contextPercent` when the window is unknown.
+ */
+export function computeContextUsedUnified(parts: {
+  inputTokens?: number | null;
+  cacheReadTokens?: number | null;
+  cacheCreateTokens?: number | null;
+  outputTokens?: number | null;
+}): number {
+  return (
+    (parts.inputTokens ?? 0) +
+    (parts.cacheReadTokens ?? 0) +
+    (parts.cacheCreateTokens ?? 0) +
+    (parts.outputTokens ?? 0)
+  );
+}
+
+/**
+ * Phase 9: clamp a raw context-percent value to [0, 100]. Returns null when
+ * `total` is missing or 0 so callers can show "unknown" instead of a
+ * divide-by-zero NaN/∞.
+ */
+export function clampContextPercent(used: number, total: number | null | undefined): number | null {
+  if (!total || total <= 0) return null;
+  const raw = (used / total) * 100;
+  if (!Number.isFinite(raw)) return null;
+  return Math.min(100, Math.max(0, raw));
+}

package/src/utils/page-session.ts

@@ -6,14 +6,16 @@
  *
  * Cookie payload: `{pageId, exp}` where `exp` is a unix seconds timestamp.
  * Wire shape: `${base64url(JSON.stringify(payload))}.${base64url(HMAC-SHA256(payload, secret))}`.
- * Secret resolution: `process.env.PAGE_SESSION_SECRET || process.env.API_KEY`
- * — the API_KEY fallback keeps existing dev setups working without forcing a
- * new env var. Verification is constant-time via `crypto.timingSafeEqual` so
- * we don't leak bits via signature-comparison timing.
+ * Secret resolution: `process.env.PAGE_SESSION_SECRET || getApiKey()`
+ * — the swarm API-key fallback keeps existing dev setups working without
+ * forcing a new env var. Verification is constant-time via
+ * `crypto.timingSafeEqual` so we don't leak bits via signature-comparison
+ * timing.
  *
  * Both functions are async because `crypto.subtle.sign` is async.
  */
 import { timingSafeEqual } from "node:crypto";
+import { getApiKey } from "./api-key";
 
 export interface PageSessionPayload {
   pageId: string;
@@ -43,12 +45,12 @@ function base64urlDecode(input: string): Uint8Array {
 
 /** Resolve the HMAC secret. */
 function getSecret(): string {
-  const secret = process.env.PAGE_SESSION_SECRET || process.env.API_KEY;
+  const secret = process.env.PAGE_SESSION_SECRET || getApiKey();
   if (!secret) {
     // Fail-closed: better to refuse to issue cookies than to mint with an
     // empty key (any attacker who learns the implementation can forge).
     throw new Error(
-      "page-session: neither PAGE_SESSION_SECRET nor API_KEY is set; refusing to sign/verify",
+      "page-session: neither PAGE_SESSION_SECRET nor swarm API key is set; refusing to sign/verify",
     );
   }
   return secret;

package/src/utils/secret-scrubber.ts

@@ -61,6 +61,8 @@ const SENSITIVE_KEY_EXACT = new Set<string>([
   "GSC_SERVICE_ACCOUNT_BASE64",
   "LINEAR_API_KEY",
   "LINEAR_OAUTH_CLIENT_SECRET",
+  "OTEL_EXPORTER_OTLP_HEADERS",
+  "SIGNOZ_INGESTION_KEY",
 ]);
 
 /** Suffixes that mark an env-var value as sensitive by convention. */
@@ -117,6 +119,11 @@ const TOKEN_REGEXES: ReadonlyArray<{ name: string; re: RegExp }> = [
     name: "jwt",
     re: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
   },
+  // SigNoz Cloud OTLP auth header values.
+  {
+    name: "signoz_ingestion_key",
+    re: /\bsignoz-ingestion-key=[A-Za-z0-9._~+/-]{20,}={0,2}\b/g,
+  },
 ];
 
 interface EnvValueEntry {
@@ -143,7 +150,7 @@ function snapshotEnv(): string {
   return parts.join("|");
 }
 
-function isSensitiveKey(key: string): boolean {
+export function isSensitiveKey(key: string): boolean {
   if (NON_SECRET_EXCEPTIONS.has(key)) return false;
   if (SENSITIVE_KEY_EXACT.has(key)) return true;
   for (const suffix of SENSITIVE_KEY_SUFFIXES) {
@@ -220,6 +227,27 @@ export function scrubSecrets(text: string | null | undefined): string {
   return out;
 }
 
+export function scrubObject<T>(value: T, seen = new WeakSet<object>()): T {
+  if (value === null || value === undefined) return value;
+  if (typeof value === "string") return scrubSecrets(value) as T;
+  if (typeof value !== "object") return value;
+
+  if (seen.has(value)) {
+    return "[Circular]" as T;
+  }
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    return value.map((item) => scrubObject(item, seen)) as T;
+  }
+
+  const out: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    out[key] = scrubObject(child, seen);
+  }
+  return out as T;
+}
+
 /**
  * Force the env-value cache to rebuild on the next scrub call. Callers should
  * invoke this whenever the swarm_config is reloaded (`/internal/reload-config`

package/src/workflows/engine.ts

@@ -16,7 +16,7 @@ import { shouldSkipCooldown } from "./cooldown";
 import { findEntryNodes, getNextTargets, getSuccessors } from "./definition";
 import type { AsyncExecutorResult } from "./executors/base";
 import type { ExecutorRegistry } from "./executors/registry";
-import { resolveInputs } from "./input";
+import { getSecretInputKeys, redactSecretsForStorage, resolveInputs } from "./input";
 import { validateJsonSchema } from "./json-schema-validator";
 import { deepInterpolate } from "./template";
 import { runStepValidation, type ValidationRunResult } from "./validation";
@@ -97,7 +97,8 @@ export async function startWorkflowExecution(
   }
 
   const entryNodes = findEntryNodes(workflow.definition);
-  await walkGraph(workflow.definition, runId, ctx, entryNodes, registry, workflow.id);
+  const secretKeys = getSecretInputKeys(workflow.input);
+  await walkGraph(workflow.definition, runId, ctx, entryNodes, registry, workflow.id, secretKeys);
   return runId;
 }
 
@@ -125,6 +126,7 @@ export async function walkGraph(
   startNodes: WorkflowNode[],
   registry: ExecutorRegistry,
   workflowId?: string,
+  secretKeys: Set<string> = new Set(),
 ): Promise<void> {
   let nodeExecutionCount = 0;
   const completedNodeIds = new Set(getCompletedStepNodeIds(runId));
@@ -232,7 +234,7 @@ export async function walkGraph(
     // Execute all pending nodes in parallel
     const results = await Promise.all(
       pendingNodes.map((node) =>
-        executeStep(def, runId, ctx, node, registry, workflowId).catch(
+        executeStep(def, runId, ctx, node, registry, workflowId, secretKeys).catch(
           (_err): StepResult => ({
             outcome: "failed",
             successors: [],
@@ -382,6 +384,7 @@ async function executeStep(
   node: WorkflowNode,
   registry: ExecutorRegistry,
   workflowId?: string,
+  secretKeys: Set<string> = new Set(),
 ): Promise<StepResult> {
   // Use iteration-aware idempotency key to support loops.
   // Count existing steps for this node to determine the current iteration.
@@ -407,13 +410,18 @@ async function executeStep(
   }
 
   // 2. Create step
+  // Redact resolved secret values from the persisted input so credentials
+  // stored in `ctx.input` (resolved via `secret.*` or sensitive `${ENV}`
+  // references) don't leak through `get-workflow-run` or any other reader of
+  // the `workflow_run_steps` table. The live `ctx` is untouched — executors
+  // still see real values.
   const stepId = crypto.randomUUID();
   createWorkflowRunStep({
     id: stepId,
     runId,
     nodeId: node.id,
     nodeType: node.type,
-    input: ctx,
+    input: redactSecretsForStorage(ctx, secretKeys),
   });
 
   // Set idempotency key

package/src/workflows/executors/index.ts

@@ -12,6 +12,7 @@ export { PropertyMatchExecutor } from "./property-match";
 export { RawLlmExecutor } from "./raw-llm";
 export { createExecutorRegistry, ExecutorRegistry } from "./registry";
 export { ScriptExecutor } from "./script";
+export { SwarmScriptExecutor } from "./swarm-script";
 export { ValidateExecutor } from "./validate";
 export { VcsExecutor } from "./vcs";
 export { WaitExecutor } from "./wait";