@desplega.ai/agent-swarm 1.131.0 → 1.131.1

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

@@ -0,0 +1,384 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { createApp, deleteApp } from "../apps/store";
+import { closeDb, createWorkflow, deleteWorkflow, getDb, initDb } from "../be/db";
+import { runMigrations } from "../be/migrations/runner";
+import { createScriptApi, getScript, insertScript, upsertScriptByName } from "../be/scripts/db";
+import { purgeExpiredScratchScripts } from "../be/scripts/retention";
+import { runSavedScriptAsAgent } from "../be/scripts/run-saved";
+
+const TEST_DB_PATH = "./test-scripts-retention.sqlite";
+const NOW = new Date("2026-08-13T12:00:00.000Z");
+const signatureJson = JSON.stringify({ args: null, result: null });
+const savedApiKey = process.env.AGENT_SWARM_API_KEY;
+
+async function clearDb(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await Bun.file(TEST_DB_PATH + suffix).delete();
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function addScript(name: string, isScratch: boolean) {
+  return insertScript({
+    name,
+    scope: "agent",
+    scopeId: "agent-1",
+    source: `export default () => "${name}"`,
+    description: name,
+    intent: name,
+    signatureJson,
+    isScratch,
+  });
+}
+
+describe("scratch script retention", () => {
+  beforeAll(async () => {
+    process.env.AGENT_SWARM_API_KEY = "scripts-retention-test-key";
+    await clearDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await clearDb();
+    if (savedApiKey === undefined) delete process.env.AGENT_SWARM_API_KEY;
+    else process.env.AGENT_SWARM_API_KEY = savedApiKey;
+  });
+
+  beforeEach(() => {
+    getDb().run("DELETE FROM scripts");
+  });
+
+  test("purges only scratch-prefixed rows inactive for more than 14 days", () => {
+    const staleScratch = addScript("scratch-stale-a1b2c3d4", true);
+    const freshScratch = addScript("scratch-fresh-a1b2c3d4", true);
+    const namedWithPrefix = addScript("scratch-named-a1b2c3d4", false);
+    const flaggedWithoutPrefix = addScript("temporary-script", true);
+    const globalScratch = insertScript({
+      name: "scratch-global-a1b2c3d4",
+      scope: "global",
+      source: "export default () => 'global'",
+      description: "global",
+      intent: "global",
+      signatureJson,
+      isScratch: true,
+    });
+
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?, ?, ?)")
+      .run(
+        "2026-07-01T00:00:00.000Z",
+        staleScratch.id,
+        namedWithPrefix.id,
+        flaggedWithoutPrefix.id,
+        globalScratch.id,
+      );
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?")
+      .run("2026-08-10T00:00:00.000Z", freshScratch.id);
+
+    expect(purgeExpiredScratchScripts(NOW)).toBe(1);
+    expect(getScript({ name: staleScratch.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+    expect(
+      getScript({ name: freshScratch.name, scope: "agent", scopeId: "agent-1" }),
+    ).not.toBeNull();
+    expect(
+      getScript({ name: namedWithPrefix.name, scope: "agent", scopeId: "agent-1" }),
+    ).not.toBeNull();
+    expect(
+      getScript({ name: flaggedWithoutPrefix.name, scope: "agent", scopeId: "agent-1" }),
+    ).not.toBeNull();
+    expect(getScript({ name: globalScratch.name, scope: "global" })).not.toBeNull();
+  });
+
+  test("a stale scratch script referenced by an app definition survives the sweep", () => {
+    const wired = addScript("scratch-app-wired-a1b2c3d4", true);
+    const unwired = addScript("scratch-app-unwired-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?)")
+      .run(old, wired.id, unwired.id);
+
+    const app = createApp({
+      name: "retention-test-app",
+      definition: {
+        models: {},
+        actions: { run: { kind: "script", scriptId: wired.id } },
+        pages: { main: { root: "root", elements: { root: { type: "Container", props: {} } } } },
+        defaultPage: "main",
+      },
+    });
+
+    try {
+      expect(purgeExpiredScratchScripts(NOW)).toBe(1);
+      expect(getScript({ name: wired.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+      expect(getScript({ name: unwired.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+    } finally {
+      deleteApp(app.id);
+    }
+  });
+
+  test("a stale scratch script referenced only by a broken app's raw definition string survives the sweep", () => {
+    const wired = addScript("scratch-broken-wired-a1b2c3d4", true);
+    const unwired = addScript("scratch-broken-unwired-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?)")
+      .run(old, wired.id, unwired.id);
+
+    const app = createApp({
+      name: "retention-test-broken-app",
+      definition: {
+        models: {},
+        actions: {},
+        pages: { main: { root: "root", elements: { root: { type: "Container", props: {} } } } },
+        defaultPage: "main",
+      },
+    });
+    // Corrupt the stored JSON so decodeApp() falls into the invalid-JSON
+    // branch: `definition` becomes the raw string itself, and the wired
+    // script's id survives only inside that unparseable text.
+    getDb()
+      .prepare("UPDATE apps SET definition = ? WHERE id = ?")
+      .run(`{"actions": {"run": {"scriptId": "${wired.id}"`, app.id);
+
+    try {
+      expect(purgeExpiredScratchScripts(NOW)).toBe(1);
+      expect(getScript({ name: wired.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+      expect(getScript({ name: unwired.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+    } finally {
+      deleteApp(app.id);
+    }
+  });
+
+  test("a stale scratch script bound to a public API endpoint survives the sweep", () => {
+    const wired = addScript("scratch-api-wired-a1b2c3d4", true);
+    const unwired = addScript("scratch-api-unwired-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?)")
+      .run(old, wired.id, unwired.id);
+
+    createScriptApi({ scriptId: wired.id, agentId: "agent-1", authMode: "none" });
+
+    expect(purgeExpiredScratchScripts(NOW)).toBe(1);
+    expect(getScript({ name: wired.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+    expect(getScript({ name: unwired.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+  });
+
+  test("a stale scratch script referenced by an agent-scoped workflow swarm-script node survives the sweep", () => {
+    const wired = addScript("scratch-wf-wired-a1b2c3d4", true);
+    const unwired = addScript("scratch-wf-unwired-a1b2c3d4", true);
+    const wrongOwner = addScript("scratch-wf-wrongowner-a1b2c3d4", true);
+    const globalNode = addScript("scratch-wf-global-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?, ?, ?)")
+      .run(old, wired.id, unwired.id, wrongOwner.id, globalNode.id);
+
+    const workflow = createWorkflow({
+      name: "retention-test-workflow",
+      definition: {
+        nodes: [
+          {
+            id: "run-it",
+            type: "swarm-script",
+            config: { scriptName: wired.name, scope: "agent" },
+          },
+          {
+            id: "run-global",
+            type: "swarm-script",
+            config: { scriptName: globalNode.name, scope: "global" },
+          },
+        ],
+        onNodeFailure: "fail",
+      },
+      createdByAgentId: "agent-1",
+    });
+    // Same script name, wrong workflow owner — must not protect wrongOwner's row.
+    const otherOwnerWorkflow = createWorkflow({
+      name: "retention-test-workflow-other-owner",
+      definition: {
+        nodes: [
+          {
+            id: "run-it",
+            type: "swarm-script",
+            config: { scriptName: wrongOwner.name, scope: "agent" },
+          },
+        ],
+        onNodeFailure: "fail",
+      },
+      createdByAgentId: "agent-2",
+    });
+
+    try {
+      expect(purgeExpiredScratchScripts(NOW)).toBe(3);
+      expect(getScript({ name: wired.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+      expect(getScript({ name: unwired.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+      expect(getScript({ name: wrongOwner.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+      expect(getScript({ name: globalNode.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+    } finally {
+      deleteWorkflow(workflow.id);
+      deleteWorkflow(otherOwnerWorkflow.id);
+    }
+  });
+
+  test("a stale scratch script referenced by an ownerless workflow's swarm-script node survives by name alone", () => {
+    const wired = addScript("scratch-wf-ownerless-wired-a1b2c3d4", true);
+    const unwired = addScript("scratch-wf-ownerless-unwired-a1b2c3d4", true);
+    const globalNode = addScript("scratch-wf-ownerless-global-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?, ?)")
+      .run(old, wired.id, unwired.id, globalNode.id);
+
+    // No createdByAgentId: the resolving agent is only known at trigger time
+    // (SwarmScriptExecutor falls back to trigger.agentId), so the sweep can only
+    // match by script name across every agent scope.
+    const workflow = createWorkflow({
+      name: "retention-test-workflow-ownerless",
+      definition: {
+        nodes: [
+          {
+            id: "run-it",
+            type: "swarm-script",
+            config: { scriptName: wired.name, scope: "agent" },
+          },
+          {
+            id: "run-global",
+            type: "swarm-script",
+            config: { scriptName: globalNode.name, scope: "global" },
+          },
+        ],
+        onNodeFailure: "fail",
+      },
+    });
+
+    try {
+      expect(purgeExpiredScratchScripts(NOW)).toBe(2);
+      expect(getScript({ name: wired.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+      expect(getScript({ name: unwired.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+      expect(getScript({ name: globalNode.name, scope: "agent", scopeId: "agent-1" })).toBeNull();
+    } finally {
+      deleteWorkflow(workflow.id);
+    }
+  });
+
+  test("a repeated successful scratch auto-save refreshes last-used time without a version bump", async () => {
+    const args = {
+      name: "scratch-reused-a1b2c3d4",
+      scope: "agent" as const,
+      scopeId: "agent-1",
+      source: "export default () => 1",
+      description: "scratch",
+      intent: "scratch",
+      signatureJson,
+      isScratch: true,
+    };
+    const created = await upsertScriptByName(args);
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?")
+      .run("2026-07-01T00:00:00.000Z", created.script.id);
+
+    const reused = await upsertScriptByName(args);
+
+    expect(reused.contentDeduped).toBe(true);
+    expect(reused.script.version).toBe(1);
+    expect(reused.script.updatedAt).not.toBe("2026-07-01T00:00:00.000Z");
+  });
+
+  test("a successful shared saved-script execution refreshes scratch last-used time", async () => {
+    const script = addScript("scratch-app-action-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb().prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?").run(old, script.id);
+
+    const output = await runSavedScriptAsAgent({ script, input: null, agentId: "agent-1" });
+
+    expect(output.exitCode).toBe(0);
+    expect(
+      getScript({ name: script.name, scope: "agent", scopeId: "agent-1" })?.updatedAt,
+    ).not.toBe(old);
+  });
+
+  test("a stale scratch script survives a GC tick that fires while its run is still in flight", async () => {
+    const script = addScript("scratch-inflight-a1b2c3d4", true);
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb().prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?").run(old, script.id);
+
+    // Don't await yet: runSavedScriptAsAgent touches last-used synchronously
+    // before its first `await`, so by the time this line returns the row is
+    // already fresh — mirroring a run that's still executing when the daily
+    // GC tick fires.
+    const runPromise = runSavedScriptAsAgent({ script, input: null, agentId: "agent-1" });
+
+    expect(purgeExpiredScratchScripts(NOW)).toBe(0);
+    expect(getScript({ name: script.name, scope: "agent", scopeId: "agent-1" })).not.toBeNull();
+
+    const output = await runPromise;
+    expect(output.exitCode).toBe(0);
+  });
+
+  test("a failed saved-script execution restores the pre-run last-used time instead of extending it", async () => {
+    const script = insertScript({
+      name: "scratch-failing-a1b2c3d4",
+      scope: "agent",
+      scopeId: "agent-1",
+      source: "export default () => { throw new Error('boom'); }",
+      description: "scratch-failing",
+      intent: "scratch-failing",
+      signatureJson,
+      isScratch: true,
+    });
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb().prepare("UPDATE scripts SET updatedAt = ? WHERE id = ?").run(old, script.id);
+    const staleScript = getScript({
+      name: script.name,
+      scope: "agent",
+      scopeId: "agent-1",
+    });
+    if (!staleScript) throw new Error("expected script to exist");
+
+    const output = await runSavedScriptAsAgent({
+      script: staleScript,
+      input: null,
+      agentId: "agent-1",
+    });
+
+    expect(output.exitCode).not.toBe(0);
+    expect(getScript({ name: script.name, scope: "agent", scopeId: "agent-1" })?.updatedAt).toBe(
+      old,
+    );
+  });
+
+  test("migration grants existing agent scratch rows a fresh retention window only", () => {
+    const agentScratch = addScript("scratch-existing-a1b2c3d4", true);
+    const namedWithPrefix = addScript("scratch-existing-named-a1b2c3d4", false);
+    const globalScratch = insertScript({
+      name: "scratch-existing-global-a1b2c3d4",
+      scope: "global",
+      source: "export default () => 'global'",
+      description: "global",
+      intent: "global",
+      signatureJson,
+      isScratch: true,
+    });
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE id IN (?, ?, ?)")
+      .run(old, agentScratch.id, namedWithPrefix.id, globalScratch.id);
+    getDb().run("DELETE FROM _migrations WHERE version = 130");
+
+    runMigrations(getDb());
+
+    expect(
+      getScript({ name: agentScratch.name, scope: "agent", scopeId: "agent-1" })?.updatedAt,
+    ).not.toBe(old);
+    expect(
+      getScript({ name: namedWithPrefix.name, scope: "agent", scopeId: "agent-1" })?.updatedAt,
+    ).toBe(old);
+    expect(getScript({ name: globalScratch.name, scope: "global" })?.updatedAt).toBe(old);
+  });
+});

package/src/tests/workflow-swarm-script.test.ts

@@ -11,7 +11,7 @@ import {
   initDb,
 } from "../be/db";
 import { upsertScriptConnection } from "../be/script-connections";
-import { upsertScriptByName } from "../be/scripts/db";
+import { getScript, upsertScriptByName } from "../be/scripts/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import type { Workflow, WorkflowDefinition } from "../types";
 import { startWorkflowExecution } from "../workflows/engine";
@@ -90,7 +90,7 @@ function makeWorkflow(def: WorkflowDefinition): Workflow {
   return wf;
 }
 
-async function saveScript(name: string, source: string) {
+async function saveScript(name: string, source: string, isScratch = false) {
   return upsertScriptByName({
     name,
     scope: "agent",
@@ -101,6 +101,7 @@ async function saveScript(name: string, source: string) {
     signatureJson,
     agentId,
     typeChecked: true,
+    isScratch,
   });
 }
 
@@ -185,14 +186,19 @@ describe("SwarmScriptExecutor", () => {
 
   test("A workflow with one swarm-script node resolves by name + runs + returns result", async () => {
     await saveScript(
-      "add-one",
+      "scratch-add-one-a1b2c3d4",
       `export default async (args: { value: number }) => ({ value: args.value + 1 });`,
+      true,
     );
+    const old = "2026-07-01T00:00:00.000Z";
+    getDb()
+      .prepare("UPDATE scripts SET updatedAt = ? WHERE name = ? AND scopeId = ?")
+      .run(old, "scratch-add-one-a1b2c3d4", agentId);
 
     const executor = new SwarmScriptExecutor(deps);
     const wf = makeWorkflow({ nodes: [] });
     const result = await executor.run({
-      config: { scriptName: "add-one", args: { value: 6 } },
+      config: { scriptName: "scratch-add-one-a1b2c3d4", args: { value: 6 } },
       context: {},
       meta: {
         runId: crypto.randomUUID(),
@@ -205,7 +211,10 @@ describe("SwarmScriptExecutor", () => {
 
     expect(result.status).toBe("success");
     expect(result.output?.result).toEqual({ value: 7 });
-    expect(result.output?.scriptName).toBe("add-one");
+    expect(result.output?.scriptName).toBe("scratch-add-one-a1b2c3d4");
+    expect(
+      getScript({ name: "scratch-add-one-a1b2c3d4", scope: "agent", scopeId: agentId })?.updatedAt,
+    ).not.toBe(old);
   });
 
   test("named script source with an interpolation token fails with the node and token named", async () => {

package/src/utils/sandboxed-process.ts

@@ -35,20 +35,36 @@ export const DEFAULT_SANDBOX_LIMITS: SandboxResourceLimits = {
 };
 
 /**
- * Bun's Linux runtime reserves several GB of virtual address space at
- * startup, so any sandboxed command whose argv[0] is `bun` needs a much
- * higher RLIMIT_AS floor than a plain shell/python process or the harness is
- * killed before user code ever runs. `buildSandboxedCommand` applies this
- * automatically — callers don't need to special-case it.
+ * Bun and Node reserve several GB of virtual address space and start runtime
+ * threads before user code runs. Give their process trees enough RLIMIT_AS
+ * and RLIMIT_NPROC headroom to boot while retaining the stricter defaults for
+ * direct non-interpreter commands.
  */
 export const BUN_SANDBOX_VIRTUAL_MEMORY_MB = 4096;
+export const JAVASCRIPT_RUNTIME_SANDBOX_MAX_PROCS = 512;
+
+const JAVASCRIPT_RUNTIMES = new Set(["bun", "bunx", "node", "nodejs", "npx"]);
+const SHELL_RUNTIMES = new Set(["bash", "dash", "sh"]);
+
+function commandBasename(command: string): string {
+  return command.slice(command.lastIndexOf("/") + 1);
+}
+
+function usesInterpreterSandboxProfile(innerCommand: readonly string[]): boolean {
+  const runtime = commandBasename(innerCommand[0] ?? "");
+  // A shell can invoke another interpreter through arbitrary valid shell
+  // grammar (substitutions, functions, variables, heredocs, and more). Treat
+  // the shell itself as the runtime boundary instead of letting untrusted
+  // source text select its own resource profile through brittle parsing.
+  return JAVASCRIPT_RUNTIMES.has(runtime) || SHELL_RUNTIMES.has(runtime);
+}
 
 function shellQuote(value: string): string {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 
 /**
- * Wrap `innerCommand` in a POSIX `sh -c` prelude that applies the resource
+ * Wrap `innerCommand` in a shell prelude that applies the resource
  * ulimits above, then `exec`s into a completely clean environment (`env -i`)
  * containing ONLY the entries in `env`. This is the enforcement point for
  * two invariants every spawn-user-code path must uphold:
@@ -60,7 +76,10 @@ function shellQuote(value: string): string {
  *     token / API key in `env`; pass secrets over stdin instead so they
  *     never appear in `/proc/<pid>/environ` or a child's `process.env`.
  *
- * No-ops (returns `innerCommand` unchanged) on win32, where `ulimit`/`env -i`
+ * JavaScript-capable runtime trees use Bash intentionally: Ubuntu's `/bin/sh` is
+ * dash, whose `ulimit` does not implement `-u` (RLIMIT_NPROC). Other commands
+ * retain the existing POSIX-sh sandbox behavior and its strict profile. No-ops
+ * (returns `innerCommand` unchanged) on win32, where `ulimit`/`env -i`
  * don't exist — matches the existing native.ts behavior. Because this no-op
  * means `env` is never applied on win32, callers MUST pass `env` itself
  * (not just `{ PATH }`) to `Bun.spawn` on that platform — use
@@ -74,15 +93,18 @@ export function buildSandboxedCommand(
 ): string[] {
   if (process.platform === "win32") return [...innerCommand];
 
-  const virtualMemoryMb =
-    innerCommand[0] === "bun"
-      ? Math.max(limits.virtualMemoryMb, BUN_SANDBOX_VIRTUAL_MEMORY_MB)
-      : limits.virtualMemoryMb;
+  const usesInterpreterProfile = usesInterpreterSandboxProfile(innerCommand);
+  const virtualMemoryMb = usesInterpreterProfile
+    ? Math.max(limits.virtualMemoryMb, BUN_SANDBOX_VIRTUAL_MEMORY_MB)
+    : limits.virtualMemoryMb;
+  const maxProcs = usesInterpreterProfile
+    ? Math.max(limits.maxProcs, JAVASCRIPT_RUNTIME_SANDBOX_MAX_PROCS)
+    : limits.maxProcs;
 
   const ulimits = [
     `ulimit -v ${Math.floor(virtualMemoryMb * 1024)} 2>/dev/null || true`,
     `ulimit -t ${limits.cpuTimeSec} 2>/dev/null || true`,
-    `ulimit -u ${limits.maxProcs} 2>/dev/null || true`,
+    `ulimit -u ${maxProcs} 2>/dev/null || true`,
     `ulimit -f ${limits.maxFileKb} 2>/dev/null || true`,
     `ulimit -n ${limits.maxFdCount} 2>/dev/null || true`,
   ].join("; ");
@@ -92,7 +114,11 @@ export function buildSandboxedCommand(
     .join(" ");
   const quotedInner = innerCommand.map(shellQuote).join(" ");
 
-  return ["sh", "-c", `${ulimits}; exec env -i ${envAssignments} ${quotedInner}`];
+  return [
+    usesInterpreterProfile ? "bash" : "sh",
+    "-c",
+    `${ulimits}; exec env -i ${envAssignments} ${quotedInner}`,
+  ];
 }
 
 /**
@@ -101,7 +127,7 @@ export function buildSandboxedCommand(
  *
  * On POSIX, `buildSandboxedCommand` wraps the command in an `env -i` prelude
  * that injects `env` itself into the child — Bun.spawn only needs PATH to
- * locate the `sh` binary that runs the prelude.
+ * locate the shell binary that runs the prelude.
  *
  * On win32, `buildSandboxedCommand` is a no-op (no `ulimit`/`env -i`), so
  * there is no prelude to inject `env` — it must go through Bun.spawn's own

package/src/workflows/executors/swarm-script.ts

@@ -4,7 +4,12 @@ import {
   getScriptMcpConnectionDescriptors,
 } from "../../be/script-connections";
 import { buildScriptCredentialBindingsWithFailures } from "../../be/script-credential-broker";
-import { getScript, getScriptVersion } from "../../be/scripts/db";
+import {
+  getScript,
+  getScriptVersion,
+  restoreScratchScriptLastUsedIfUnchanged,
+  touchScratchScriptLastUsed,
+} from "../../be/scripts/db";
 import {
   DEFAULT_SCRIPT_RESOURCES,
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -104,6 +109,12 @@ export class SwarmScriptExecutor extends BaseExecutor<
       };
     }
 
+    // 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 = resolved.script.isScratch
+      ? touchScratchScriptLastUsed(resolved.script.id)
+      : null;
+
     const credentials = await buildScriptCredentialBindingsWithFailures({
       agentId: agentId ?? undefined,
     });
@@ -118,6 +129,18 @@ export class SwarmScriptExecutor extends BaseExecutor<
       mcpConnections: getScriptMcpConnectionDescriptors({ agentId: agentId ?? undefined }),
       timeoutMs: config.timeoutMs,
     });
+    if (output.exitCode === 0 && !output.error && !output.runtimeError) {
+      touchScratchScriptLastUsed(resolved.script.id);
+    } else if (resolved.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(
+        resolved.script.id,
+        resolved.script.updatedAt,
+        runStartTouch,
+      );
+    }
 
     const workflowOutput = {
       result: output.result,

package/templates/schedules/daily-compounding-reflection/content.md

@@ -122,19 +122,28 @@ Skills are the swarm's procedural knowledge — tested playbooks for how to do t
 
 ### 3A. Identify Skill Candidates
 - Review completed tasks: Was any task done by researching something that should have been a skill?
-- Look for repeated patterns: Has the same type of task been done 3+ times with a stable approach?
+- Skillify a reusable method the first time it has been validated.
 - Check failed tasks: Did an agent waste context on research that a skill could have prevented?
 - Review agent sessions: Did any agent ignore an existing skill and re-derive the same knowledge? (This is a skill discoverability problem.)
 
 ### 3B. Create New Skills
 For each candidate:
 1. Draft the skill content (procedure, examples, gotchas)
-2. Use `skill-create` with clear name, description, and `agentAutoTrigger` field
+2. Use `skill-create` with full skill content containing a clear name and description
 3. Use `skill-install` to install it for relevant agents
 4. The description and trigger fields are CRITICAL — they determine whether agents find and use the skill
 
 ### 3C. Update Existing Skills
-- Use `skill-list` with `includeContent: true` to review current skills
+- Audit skill bodies inside a one-off `script-run`, using `ctx.swarm.db_query`; do not load the bodies into model context with direct `db-query`, and do not use `skill-list includeContent`.
+- Inside the script, count the enabled skills, then fetch them in explicit pages smaller than the 100-row tool cap (for example, 50 rows at a time):
+  ```sql
+  SELECT COUNT(*) FROM skills WHERE isEnabled = 1;
+  SELECT id, name, scope, ownerAgentId, description, content FROM skills
+  WHERE isEnabled = 1 ORDER BY name LIMIT 50 OFFSET <offset>;
+  ```
+- Inspect each page inside the script, continue until the final short page, and return only aggregate counts plus a compact list of findings (skill ID, name, scope/owner, issue, and proposed action) — never the skill bodies. `skill-update` requires the ID, and names are only unique within scope/owner. Require the processed-row count to equal the initial count before treating the audit as complete. Script-internal `ctx.swarm.*` calls bypass the model-context response ceiling and instead fail loudly at the separate 64 MiB guard; pagination also prevents silent row truncation.
+- Before accepting any zero-hit content audit as clean, carry a positive control through the same search path: choose a distinctive token visibly present in one returned skill body and verify that the audit finds it. If the positive control returns zero, treat the audit as invalid rather than clean.
+- Carry a negative control too: search for a freshly invented token that cannot be present and require zero matches. Report both control counts with the processed-row count.
 - Are any skills outdated (e.g., referencing old APIs, wrong procedures)?
 - Are any skills not being used? Check if the description/trigger is too vague
 - Update skills with `skill-update` as needed