@desplega.ai/agent-swarm 1.131.0 → 1.131.1

package/src/be/scripts/run-saved.ts

@@ -5,6 +5,7 @@ import {
   getScriptMcpConnectionDescriptors,
 } from "../script-connections";
 import { buildScriptCredentialBindingsWithFailures } from "../script-credential-broker";
+import { restoreScratchScriptLastUsedIfUnchanged, touchScratchScriptLastUsed } from "./db";
 
 export function getSavedScriptOwnerAgentId(script: ScriptRecord): string | null {
   return script.scopeId ?? script.createdByAgentId;
@@ -16,10 +17,15 @@ export async function runSavedScriptAsAgent(args: {
   input: unknown;
   agentId: string;
 }) {
+  // Touch before executing (not just after) so a scratch script that's already
+  // stale when a run starts can't be reaped by the retention sweep while the
+  // run — which may take up to the runtime's wall-clock ceiling — is in flight.
+  const runStartTouch = args.script.isScratch ? touchScratchScriptLastUsed(args.script.id) : null;
+
   const credentials = await buildScriptCredentialBindingsWithFailures({
     agentId: args.agentId,
   });
-  return runScript({
+  const output = await runScript({
     source: args.script.source,
     args: args.input,
     fsMode: args.script.fsMode,
@@ -29,4 +35,13 @@ export async function runSavedScriptAsAgent(args: {
     apiConnections: getScriptApiConnectionDescriptors({ agentId: args.agentId }),
     mcpConnections: getScriptMcpConnectionDescriptors({ agentId: args.agentId }),
   });
+  if (output.exitCode === 0 && !output.error && !output.runtimeError) {
+    touchScratchScriptLastUsed(args.script.id);
+  } else if (runStartTouch) {
+    // The run-start touch didn't pan out — restore the pre-run timestamp so a
+    // failed invocation doesn't buy the script another retention window, as
+    // long as no concurrent run has touched it since.
+    restoreScratchScriptLastUsedIfUnchanged(args.script.id, args.script.updatedAt, runStartTouch);
+  }
+  return output;
 }

package/src/http/index.ts

@@ -17,6 +17,7 @@ import {
   stopAuditGc,
   stopAuditWriter,
 } from "../be/rbac-audit";
+import { startScratchScriptGc, stopScratchScriptGc } from "../be/scripts/retention";
 import { seedLegacyCapabilitiesConfig } from "../be/seed-capabilities";
 import { initGitHub } from "../github";
 import { initGitLab } from "../gitlab";
@@ -441,6 +442,9 @@ async function shutdown() {
   // Stop memory expired-row garbage collector
   stopMemoryGc();
 
+  // Stop scratch-script retention garbage collector
+  stopScratchScriptGc();
+
   // Stop RBAC audit: retention GC, flush interval, final drain, detach sink
   stopAuditGc();
   stopAuditWriter();
@@ -561,6 +565,7 @@ try {
 setAuditSink(enqueueAuditRow);
 startAuditWriter();
 startAuditGc();
+startScratchScriptGc();
 
 // business-use initialization (no-op if envs not set)
 initialize();

package/src/http/scripts.ts

@@ -24,7 +24,9 @@ import {
   listScriptApisForScript,
   listScripts,
   listScriptVersions,
+  restoreScratchScriptLastUsedIfUnchanged,
   rotateScriptApiSecret,
+  touchScratchScriptLastUsed,
   updateScriptApi,
   upsertScriptByName,
 } from "../be/scripts/db";
@@ -695,12 +697,14 @@ export async function handleScripts(
 
     let source = parsed.body.source;
     let fsMode = parsed.body.fsMode;
+    let namedScript: ScriptRecord | null = null;
     if (parsed.body.name) {
       const script = resolveScript(parsed.body.name, agent.id, parsed.body.scope);
       if (!script) {
         jsonError(res, "Script not found", 404);
         return true;
       }
+      namedScript = script;
       source = script.source;
       fsMode = script.fsMode;
     }
@@ -711,6 +715,11 @@ export async function handleScripts(
     }
 
     const startedAt = new Date().toISOString();
+    // Touch before executing so an already-stale scratch script isn't reaped
+    // by the retention sweep while this run is still in flight.
+    const runStartTouch = namedScript?.isScratch
+      ? touchScratchScriptLastUsed(namedScript.id)
+      : null;
     const credentials = await buildScriptCredentialBindingsWithFailures({ agentId: agent.id });
     const output = await runScript({
       source: source as string,
@@ -722,10 +731,20 @@ export async function handleScripts(
       apiConnections: getScriptApiConnectionDescriptors({ agentId: agent.id }),
       mcpConnections: getScriptMcpConnectionDescriptors({ agentId: agent.id }),
     });
+    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
+
+    if (namedScript?.isScratch && ok) {
+      touchScratchScriptLastUsed(namedScript.id);
+    } else if (namedScript?.isScratch && runStartTouch) {
+      // Failed run — restore the pre-run timestamp so it doesn't buy the
+      // script another retention window, unless a concurrent run already
+      // touched it since.
+      restoreScratchScriptLastUsedIfUnchanged(namedScript.id, namedScript.updatedAt, runStartTouch);
+    }
 
     // Persist output to KV when idempotencyKey is provided and run succeeded
     let kvSaved: { namespace: string; key: string } | undefined;
-    if (parsed.body.idempotencyKey && !output.error && output.exitCode === 0) {
+    if (parsed.body.idempotencyKey && ok) {
       const kvNamespace = `script:executions`;
       const kvKey = parsed.body.idempotencyKey;
       const kvValue = {
@@ -745,7 +764,7 @@ export async function handleScripts(
     }
 
     let autoSaved: { slug: string; reason: string } | undefined;
-    if (parsed.body.source && !output.error && output.exitCode === 0) {
+    if (parsed.body.source && ok) {
       const slug = scratchSlug(parsed.body.intent, parsed.body.source);
       await upsertScriptByName({
         name: slug,
@@ -767,7 +786,6 @@ export async function handleScripts(
     // Persist the inline run (no journal) so one-off executions show up alongside
     // durable workflow runs in the Script Runs dashboard. Best-effort: recording
     // must never fail the actual execution.
-    const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
     const runError = ok
       ? undefined
       : scrubSecrets(

package/src/http/x.ts

@@ -12,6 +12,8 @@ import {
   getScriptApiSecret,
   getScriptById,
   recordScriptApiUsage,
+  restoreScratchScriptLastUsedIfUnchanged,
+  touchScratchScriptLastUsed,
 } from "../be/scripts/db";
 import {
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -228,6 +230,10 @@ export async function handleX(
   const timeoutMs = resolveTimeoutMs(req);
   const startedAt = new Date().toISOString();
 
+  // Touch before executing so an already-stale scratch script isn't reaped by
+  // the retention sweep while this run is still in flight.
+  const runStartTouch = script.isScratch ? touchScratchScriptLastUsed(script.id) : null;
+
   const credentials = await buildScriptCredentialBindingsWithFailures({
     agentId: endpoint.agentId,
   });
@@ -250,6 +256,14 @@ export async function handleX(
 
   const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
   const error = ok ? null : buildExecutionError(output);
+  if (ok) {
+    touchScratchScriptLastUsed(script.id);
+  } else if (script.isScratch && runStartTouch) {
+    // Failed run — restore the pre-run timestamp so it doesn't buy the
+    // script another retention window, unless a concurrent run already
+    // touched it since.
+    restoreScratchScriptLastUsedIfUnchanged(script.id, script.updatedAt, runStartTouch);
+  }
 
   // Usage + observability — best-effort, must never fail the response.
   try {

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

@@ -38,8 +38,8 @@ export const CLAUDE_MANAGED_MODELS = [
 
 export type ClaudeManagedModel = (typeof CLAUDE_MANAGED_MODELS)[number];
 
-/** Pricing per million tokens (USD). */
-export interface ClaudeManagedModelPricing {
+/** Token rates per million tokens (USD). */
+export interface ClaudeManagedTokenPricing {
   /** USD per million uncached input tokens. */
   inputPerMillion: number;
   /** USD per million output tokens. */
@@ -50,6 +50,15 @@ export interface ClaudeManagedModelPricing {
   cacheWritePerMillion: number;
 }
 
+/** Pricing per million tokens (USD), including an optional scheduled rate change. */
+export interface ClaudeManagedModelPricing extends ClaudeManagedTokenPricing {
+  scheduledChange?: {
+    /** ISO timestamp at which the replacement rates take effect. */
+    effectiveAt: string;
+    pricing: ClaudeManagedTokenPricing;
+  };
+}
+
 /**
  * Anthropic public list pricing. Source:
  * https://platform.claude.com/docs/en/about-claude/pricing
@@ -57,7 +66,7 @@ export interface ClaudeManagedModelPricing {
  * - claude-fable-5:   $10 / $50 / $1.00 / $12.50   (verified 2026-06-10)
  * - claude-mythos-5:  $10 / $50 / $1.00 / $12.50   (limited availability, verified 2026-06-10)
  * - claude-opus-5:    $5 / $25 / $0.50 / $6.25     (verified 2026-07-25)
- * - claude-sonnet-5:  $3 / $15 / $0.30 / $3.75     (verified 2026-06-30; intro $2/$10 through 2026-08-31)
+ * - claude-sonnet-5:  $2 / $10 / $0.20 / $2.50     (introductory rate, verified 2026-08-11; $3/$15 from 2026-09-01)
  * - claude-sonnet-4-6: $3 / $15 / $0.30 / $3.75    (in / out / cache-read / cache-write)
  * - claude-opus-4-8:   $5 / $25 / $0.50 / $6.25    (verified 2026-05-28)
  * - claude-opus-4-7:   $15 / $75 / $1.50 / $18.75  (STALE — was correct at launch, Anthropic has since dropped Opus to $5/$25)
@@ -83,12 +92,21 @@ export const CLAUDE_MANAGED_MODEL_PRICING: Record<ClaudeManagedModel, ClaudeMana
     cacheReadPerMillion: 1.0,
     cacheWritePerMillion: 12.5,
   },
-  // intro $2/$10 through 2026-08-31
+  // Introductory rate through 2026-08-31; changes to $3/$15 from 2026-09-01.
   "claude-sonnet-5": {
-    inputPerMillion: 3.0,
-    outputPerMillion: 15.0,
-    cacheReadPerMillion: 0.3,
-    cacheWritePerMillion: 3.75,
+    inputPerMillion: 2.0,
+    outputPerMillion: 10.0,
+    cacheReadPerMillion: 0.2,
+    cacheWritePerMillion: 2.5,
+    scheduledChange: {
+      effectiveAt: "2026-09-01T00:00:00.000Z",
+      pricing: {
+        inputPerMillion: 3.0,
+        outputPerMillion: 15.0,
+        cacheReadPerMillion: 0.3,
+        cacheWritePerMillion: 3.75,
+      },
+    },
   },
   "claude-sonnet-4-6": {
     inputPerMillion: 3.0,
@@ -146,9 +164,10 @@ export function computeClaudeManagedCostUsd(
   outputTokens: number,
   cacheReadTokens: number,
   cacheWriteTokens: number,
+  pricedAtMs: number = Date.now(),
 ): number {
-  const pricing = CLAUDE_MANAGED_MODEL_PRICING[model as ClaudeManagedModel];
-  if (!pricing) {
+  const configuredPricing = CLAUDE_MANAGED_MODEL_PRICING[model as ClaudeManagedModel];
+  if (!configuredPricing) {
     if (!warnedUnknownModels.has(model)) {
       warnedUnknownModels.add(model);
       console.warn(
@@ -158,6 +177,11 @@ export function computeClaudeManagedCostUsd(
     }
     return 0;
   }
+  const pricing =
+    configuredPricing.scheduledChange &&
+    pricedAtMs >= Date.parse(configuredPricing.scheduledChange.effectiveAt)
+      ? configuredPricing.scheduledChange.pricing
+      : configuredPricing;
   const inputCost = (inputTokens / 1_000_000) * pricing.inputPerMillion;
   const outputCost = (outputTokens / 1_000_000) * pricing.outputPerMillion;
   const cacheReadCost = (cacheReadTokens / 1_000_000) * pricing.cacheReadPerMillion;

package/src/tests/claude-managed-adapter.test.ts

@@ -831,11 +831,33 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
     expect(cost).toBeCloseTo(4.5, 10);
   });
 
-  test("computeClaudeManagedCostUsd returns expected USD for sonnet-5 against list rate", () => {
+  test("computeClaudeManagedCostUsd uses sonnet-5 introductory rate through 2026-08-31", () => {
+    // 1M input tokens × $2.00/Mtok = $2.00
+    // 100k output tokens × $10.00/Mtok = $1.00
+    // total = $3.00. The introductory rate applies through 2026-08-31.
+    const cost = computeClaudeManagedCostUsd(
+      "claude-sonnet-5",
+      1_000_000,
+      100_000,
+      0,
+      0,
+      Date.parse("2026-08-31T23:59:59.999Z"),
+    );
+    expect(cost).toBeCloseTo(3.0, 10);
+  });
+
+  test("computeClaudeManagedCostUsd uses sonnet-5 standard rate from 2026-09-01", () => {
     // 1M input tokens × $3.00/Mtok = $3.00
     // 100k output tokens × $15.00/Mtok = $1.50
-    // total = $4.50. Intro $2/$10 pricing is intentionally not used here.
-    const cost = computeClaudeManagedCostUsd("claude-sonnet-5", 1_000_000, 100_000, 0, 0);
+    // total = $4.50 from the first instant of 2026-09-01 UTC.
+    const cost = computeClaudeManagedCostUsd(
+      "claude-sonnet-5",
+      1_000_000,
+      100_000,
+      0,
+      0,
+      Date.parse("2026-09-01T00:00:00.000Z"),
+    );
     expect(cost).toBeCloseTo(4.5, 10);
   });
 
@@ -882,10 +904,19 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
       cacheWritePerMillion: 12.5,
     });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5"]).toEqual({
-      inputPerMillion: 3.0,
-      outputPerMillion: 15.0,
-      cacheReadPerMillion: 0.3,
-      cacheWritePerMillion: 3.75,
+      inputPerMillion: 2.0,
+      outputPerMillion: 10.0,
+      cacheReadPerMillion: 0.2,
+      cacheWritePerMillion: 2.5,
+      scheduledChange: {
+        effectiveAt: "2026-09-01T00:00:00.000Z",
+        pricing: {
+          inputPerMillion: 3.0,
+          outputPerMillion: 15.0,
+          cacheReadPerMillion: 0.3,
+          cacheWritePerMillion: 3.75,
+        },
+      },
     });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-4-6"]).toBeDefined();
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-4-7"]).toBeDefined();

package/src/tests/sandboxed-process.test.ts

@@ -1,12 +1,21 @@
 import { describe, expect, test } from "bun:test";
 import {
+  BUN_SANDBOX_VIRTUAL_MEMORY_MB,
   buildSandboxedCommand,
   createCappedStreamState,
+  DEFAULT_SANDBOX_LIMITS,
+  JAVASCRIPT_RUNTIME_SANDBOX_MAX_PROCS,
   readStreamCapped,
   sandboxSpawnEnv,
   snapshotCapped,
 } from "../utils/sandboxed-process";
 
+const TEST_ENV = { PATH: process.env.PATH ?? "/usr/bin:/bin", HOME: "/tmp" };
+
+function sandboxPrelude(command: readonly string[]): string {
+  return buildSandboxedCommand(command, TEST_ENV)[2] ?? "";
+}
+
 /**
  * Temporarily override `process.platform` for the duration of `fn`, then
  * restore it. Used to exercise the win32 branches of `buildSandboxedCommand`
@@ -56,6 +65,42 @@ describe("sandboxSpawnEnv", () => {
   });
 });
 
+describe("buildSandboxedCommand runtime-aware limits", () => {
+  test.each(["bun", "node", "npx"])("raises AS and nproc for direct %s commands", (runtime) => {
+    const command = buildSandboxedCommand([runtime, "--version"], TEST_ENV);
+    expect(command[0]).toBe("bash");
+    expect(command[2]).toContain(`ulimit -v ${BUN_SANDBOX_VIRTUAL_MEMORY_MB * 1024}`);
+    expect(command[2]).toContain(`ulimit -u ${JAVASCRIPT_RUNTIME_SANDBOX_MAX_PROCS}`);
+  });
+
+  test.each(["bash", "sh", "dash"])("propagates the runtime profile through %s -c", (shell) => {
+    const script = "bun /opt/meme-post.bundle.js";
+    const prelude = sandboxPrelude([shell, "-c", script]);
+    expect(prelude).toContain(`ulimit -v ${BUN_SANDBOX_VIRTUAL_MEMORY_MB * 1024}`);
+    expect(prelude).toContain(`ulimit -u ${JAVASCRIPT_RUNTIME_SANDBOX_MAX_PROCS}`);
+  });
+
+  test("keeps strict defaults for direct non-interpreter commands", () => {
+    const command = buildSandboxedCommand(["git", "status", "--short"], TEST_ENV);
+    expect(command[0]).toBe("sh");
+    const prelude = command[2] ?? "";
+    expect(prelude).toContain(`ulimit -v ${DEFAULT_SANDBOX_LIMITS.virtualMemoryMb * 1024}`);
+    expect(prelude).toContain(`ulimit -u ${DEFAULT_SANDBOX_LIMITS.maxProcs}`);
+  });
+
+  test("the raised profile starts a shell-wrapped Bun process with real nproc enforcement", () => {
+    const result = Bun.spawnSync(
+      buildSandboxedCommand(
+        ["bash", "-c", "bun -e 'console.log(JSON.stringify({ started: true }))'"],
+        TEST_ENV,
+      ),
+      { env: sandboxSpawnEnv(TEST_ENV) },
+    );
+    expect(result.exitCode).toBe(0);
+    expect(JSON.parse(result.stdout.toString())).toEqual({ started: true });
+  });
+});
+
 // ─── readStreamCapped / snapshotCapped (Codex PRRT_kwDOQr3Tmc6XCRuy — deadline snapshot) ──
 
 describe("readStreamCapped with an external CappedStreamState", () => {

package/src/tests/script-connections.test.ts

@@ -535,9 +535,10 @@ describe("script connections", () => {
       markMigrationApplied(database, "127_backfill_user_attribution.sql");
       // 128 alters session_costs, which this partial fixture does not create.
       markMigrationApplied(database, "128_session_costs_accuracy.sql");
-      // 129 alters scripts and rebuilds asset_key_history, neither of which this
-      // migration-112-only fixture creates.
+      // 129 and 130 alter scripts (and 129 rebuilds asset_key_history), none of
+      // which this migration-112-only fixture creates.
       markMigrationApplied(database, "129_asset_keys_apps_scripts.sql");
+      markMigrationApplied(database, "130_scratch_script_retention_grace.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/scripts-external-api.test.ts

@@ -8,6 +8,7 @@ import {
   createScriptApi,
   getScriptApiById,
   getScriptApiSecret,
+  getScriptById,
   insertScript,
   listScriptApisForScript,
 } from "../be/scripts/db";
@@ -49,9 +50,9 @@ const DOUBLER_SOURCE =
 let workerId: string;
 let savedEnv: NodeJS.ProcessEnv;
 
-function insertDoubler(opts: { argsJsonSchema?: string | null } = {}) {
+function insertDoubler(opts: { argsJsonSchema?: string | null; isScratch?: boolean } = {}) {
   return insertScript({
-    name: `doubler-${crypto.randomUUID().slice(0, 8)}`,
+    name: `${opts.isScratch ? "scratch-" : ""}doubler-${crypto.randomUUID().slice(0, 8)}`,
     scope: "agent",
     scopeId: workerId,
     source: DOUBLER_SOURCE,
@@ -61,6 +62,7 @@ function insertDoubler(opts: { argsJsonSchema?: string | null } = {}) {
     argsJsonSchema: opts.argsJsonSchema ?? null,
     agentId: workerId,
     typeChecked: true,
+    isScratch: opts.isScratch,
   });
 }
 
@@ -262,7 +264,9 @@ describe("management routes", () => {
 
 describe("public execution route", () => {
   test("none-mode endpoint runs and returns the wrapped envelope", async () => {
-    const script = insertDoubler();
+    const script = insertDoubler({ isScratch: true });
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb().prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?").run(old, script.id);
     const endpoint = createScriptApi({
       scriptId: script.id,
       agentId: workerId,
@@ -285,6 +289,7 @@ describe("public execution route", () => {
     expect(body.result).toEqual({ doubled: 42 });
     expect(body.error).toBeNull();
     expect(typeof body.durationMs).toBe("number");
+    expect(getScriptById(script.id)?.updatedAt).not.toBe(old);
   });
 
   test("external endpoint runs receive ctx.mcp connections (parity with /api/scripts/run)", async () => {

package/src/tests/scripts-http.test.ts

@@ -501,6 +501,18 @@ describe("/api/scripts HTTP", () => {
     const inlineBody = await inline.json();
     expect(inlineBody.result).toEqual({ ok: "not typechecked" });
     expect(inlineBody.autoSaved.slug).toContain("scratch-inline-type-error-still-runs");
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE name = ? AND scopeId = ?")
+      .run("2026-07-01T00:00:00.000Z", inlineBody.autoSaved.slug, workerId);
+    const reusedScratch = await dispatch("/api/scripts/run", {
+      method: "POST",
+      agentId: workerId,
+      body: JSON.stringify({ name: inlineBody.autoSaved.slug }),
+    });
+    expect(reusedScratch.status).toBe(200);
+    expect(
+      getScript({ name: inlineBody.autoSaved.slug, scope: "agent", scopeId: workerId })?.updatedAt,
+    ).not.toBe("2026-07-01T00:00:00.000Z");
 
     const beforeFailed = listScripts({
       scope: "agent",