@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/tests/script-runs-http.test.ts

@@ -0,0 +1,278 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { closeDb, createAgent, getDb, initDb, updateScriptRun } from "../be/db";
+import { handleCore } from "../http/core";
+import { handleScriptRuns } from "../http/script-runs";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+
+const TEST_DB_PATH = "./test-script-runs-http.sqlite";
+const API_KEY = "test-script-runs-http-key-1234567890";
+
+let agentId: string;
+let savedEnv: NodeJS.ProcessEnv;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+beforeAll(async () => {
+  savedEnv = { ...process.env };
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  process.env.APP_URL = "https://app.example.test";
+  process.env.SCRIPT_RUN_SUPERVISOR_DISABLE = "true";
+  delete process.env.API_KEY;
+  refreshSecretScrubberCache();
+
+  const agent = createAgent({ name: "script-runs-worker", isLead: false, status: "idle" });
+  agentId = agent.id;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshSecretScrubberCache();
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM script_run_journal");
+  getDb().run("DELETE FROM script_runs");
+  delete process.env.SCRIPT_RUN_CONCURRENCY_CAP;
+  delete process.env.SCRIPT_RUN_MAX_STEPS;
+  delete process.env.SCRIPT_RUN_MAX_AGENT_TASKS;
+  delete process.env.SCRIPT_RUN_MAX_WALL_MS;
+  process.env.SCRIPT_RUN_SUPERVISOR_DISABLE = "true";
+});
+
+type TestResponse = {
+  status: number;
+  text: string;
+  json: () => Promise<unknown>;
+};
+
+async function dispatch(
+  path: string,
+  init: RequestInit & { agentId?: string } = {},
+): Promise<TestResponse> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${API_KEY}`,
+    "Content-Type": "application/json",
+    ...((init.headers as Record<string, string>) ?? {}),
+  };
+  if (init.agentId !== undefined) headers["X-Agent-ID"] = init.agentId;
+  const req = Readable.from(init.body ? [Buffer.from(String(init.body))] : []) as IncomingMessage;
+  req.method = init.method ?? "GET";
+  req.url = path;
+  req.headers = Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]),
+  );
+
+  let status = 200;
+  let text = "";
+  const res = {
+    headersSent: false,
+    writableEnded: false,
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+      this.headersSent = true;
+      return this;
+    },
+    end(chunk?: unknown) {
+      if (chunk !== undefined) text += String(chunk);
+      this.writableEnded = true;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  const requestAgentId = req.headers["x-agent-id"] as string | undefined;
+  if (!(await handleCore(req, res, requestAgentId, API_KEY))) {
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    if (!(await handleScriptRuns(req, res, pathSegments, queryParams, requestAgentId))) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  }
+
+  return {
+    status,
+    text,
+    json: async () => JSON.parse(text),
+  };
+}
+
+function createBody(extra: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    source: "export default async function main() { return { ok: true }; }",
+    args: { ok: true },
+    ...extra,
+  });
+}
+
+describe("/api/script-runs HTTP", () => {
+  test("creates and lists a script run", async () => {
+    const created = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody({ scriptName: "daily-report" }),
+    });
+    expect(created.status).toBe(201);
+    const body = (await created.json()) as { id: string; status: string; url: string };
+    expect(body.status).toBe("running");
+    expect(body.url).toBe(`https://app.example.test/script-runs/${body.id}`);
+
+    const listed = await dispatch("/api/script-runs", { agentId });
+    expect(listed.status).toBe(200);
+    const listBody = (await listed.json()) as { runs: Array<{ id: string }>; total: number };
+    expect(listBody.total).toBe(1);
+    expect(listBody.runs[0]?.id).toBe(body.id);
+  });
+
+  test("returns the existing run for an idempotency key", async () => {
+    const first = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody({ idempotencyKey: "stable-key" }),
+    });
+    const firstBody = (await first.json()) as { id: string };
+
+    const second = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody({ idempotencyKey: "stable-key" }),
+    });
+    expect(second.status).toBe(409);
+    const secondBody = (await second.json()) as { id: string };
+    expect(secondBody.id).toBe(firstBody.id);
+  });
+
+  test("rejects obvious literal labels inside loops before launch", async () => {
+    const rejected = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody({
+        source:
+          'export default async function main(args, ctx) { for (const item of args.items) { await ctx.step.agentTask("process", { task: item.task }); } }',
+      }),
+    });
+    expect(rejected.status).toBe(400);
+    const body = (await rejected.json()) as { error: string; violations: Array<{ label: string }> };
+    expect(body.error).toBe("label_lint_violation");
+    expect(body.violations[0]?.label).toBe("process");
+  });
+
+  test("records and replays journal steps through internal routes", async () => {
+    const created = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody(),
+    });
+    const { id } = (await created.json()) as { id: string };
+
+    const recorded = await dispatch(`/api/internal/script-runs/${id}/steps`, {
+      method: "POST",
+      agentId,
+      body: JSON.stringify({
+        stepKey: "summarize",
+        stepType: "raw-llm",
+        config: { prompt: "hello" },
+        status: "completed",
+        result: { text: "hi" },
+      }),
+    });
+    expect(recorded.status).toBe(201);
+
+    const replayed = await dispatch(`/api/internal/script-runs/${id}/steps/summarize`, {
+      agentId,
+    });
+    expect(replayed.status).toBe(200);
+    expect(await replayed.json()).toEqual({
+      stepKey: "summarize",
+      stepType: "raw-llm",
+      result: { text: "hi" },
+    });
+  });
+
+  test("aborts the run when the journal step cap is exceeded", async () => {
+    process.env.SCRIPT_RUN_MAX_STEPS = "1";
+    const created = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody(),
+    });
+    const { id } = (await created.json()) as { id: string };
+
+    const first = await dispatch(`/api/internal/script-runs/${id}/steps`, {
+      method: "POST",
+      agentId,
+      body: JSON.stringify({
+        stepKey: "one",
+        stepType: "swarm-script",
+        status: "completed",
+        result: 1,
+      }),
+    });
+    expect(first.status).toBe(201);
+
+    const second = await dispatch(`/api/internal/script-runs/${id}/steps`, {
+      method: "POST",
+      agentId,
+      body: JSON.stringify({
+        stepKey: "two",
+        stepType: "swarm-script",
+        status: "completed",
+        result: 2,
+      }),
+    });
+    expect(second.status).toBe(429);
+
+    const detail = await dispatch(`/api/script-runs/${id}`, { agentId });
+    const body = (await detail.json()) as { run: { status: string; error?: string } };
+    expect(body.run.status).toBe("aborted_limit");
+    expect(body.run.error).toContain("SCRIPT_RUN_MAX_STEPS");
+  });
+
+  test("cancel leaves terminal script runs unchanged", async () => {
+    const created = await dispatch("/api/script-runs", {
+      method: "POST",
+      agentId,
+      body: createBody(),
+    });
+    const { id } = (await created.json()) as { id: string };
+    updateScriptRun(id, {
+      status: "failed",
+      pid: null,
+      finishedAt: new Date().toISOString(),
+      error: "original failure",
+    });
+
+    const cancelled = await dispatch(`/api/script-runs/${id}`, {
+      method: "DELETE",
+      agentId,
+    });
+    expect(cancelled.status).toBe(204);
+
+    const detail = await dispatch(`/api/script-runs/${id}`, { agentId });
+    const body = (await detail.json()) as { run: { status: string; error?: string } };
+    expect(body.run.status).toBe("failed");
+    expect(body.run.error).toBe("original failure");
+  });
+});

package/src/tests/script-workflows-label-lint.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { lintWorkflowLabels } from "../script-workflows/label-lint";
+
+describe("lintWorkflowLabels", () => {
+  test("rejects a literal step label inside a loop", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(args, ctx) {
+        for (const item of args.items) {
+          await ctx.step.agentTask("process", { task: item.task });
+        }
+      }
+    `);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]?.label).toBe("process");
+      expect(result.errors[0]?.detail).toContain("inside a loop");
+    }
+  });
+
+  test("allows template literal step labels inside a loop", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(args, ctx) {
+        for (const item of args.items) {
+          await ctx.step.agentTask(\`process:\${item.id}\`, { task: item.task });
+        }
+      }
+    `);
+
+    expect(result).toEqual({ ok: true });
+  });
+
+  test("allows literal step labels outside loops", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(_args, ctx) {
+        await ctx.step.rawLlm("summarize", { prompt: "hello" });
+      }
+    `);
+
+    expect(result).toEqual({ ok: true });
+  });
+});

package/src/tests/script-workflows-runtime-e2e.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { rm, unlink } from "node:fs/promises";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { closeDb, createAgent, getDb, initDb, listScriptRunJournalSteps } from "../be/db";
+import { handleCore } from "../http/core";
+import { handleScriptRuns } from "../http/script-runs";
+import { handleScripts } from "../http/scripts";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+
+const TEST_DB_PATH = "./test-script-workflows-runtime-e2e.sqlite";
+const WORKFLOW_RUNTIME_DIR = "./test-script-workflows-runtime";
+const API_KEY = "test-script-workflows-runtime-key-1234567890";
+
+let agentId: string;
+let server: Server;
+let baseUrl: string;
+let savedEnv: NodeJS.ProcessEnv;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function listen(server: Server): Promise<number> {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") reject(new Error("No server address"));
+      else resolve(address.port);
+    });
+  });
+}
+
+function closeServer(server: Server): Promise<void> {
+  return new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+async function route(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const agentId = req.headers["x-agent-id"] as string | undefined;
+  if (await handleCore(req, res, agentId, API_KEY)) return;
+  const pathSegments = getPathSegments(req.url || "");
+  const queryParams = parseQueryParams(req.url || "");
+  if (await handleScriptRuns(req, res, pathSegments, queryParams, agentId)) return;
+  if (await handleScripts(req, res, pathSegments, queryParams, agentId)) return;
+  res.writeHead(404);
+  res.end("Not Found");
+}
+
+async function api(path: string, init: RequestInit = {}): Promise<Response> {
+  return fetch(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "X-Agent-ID": agentId,
+      "Content-Type": "application/json",
+      ...((init.headers as Record<string, string>) ?? {}),
+    },
+  });
+}
+
+async function waitForRun(
+  id: string,
+): Promise<{ status: string; output?: unknown; error?: string }> {
+  const deadline = Date.now() + 10_000;
+  while (Date.now() < deadline) {
+    const res = await api(`/api/script-runs/${id}`);
+    const body = (await res.json()) as {
+      run: { status: string; output?: unknown; error?: string };
+    };
+    if (["completed", "failed", "cancelled", "aborted_limit"].includes(body.run.status)) {
+      return body.run;
+    }
+    await Bun.sleep(250);
+  }
+  throw new Error("Timed out waiting for script run");
+}
+
+beforeAll(async () => {
+  savedEnv = { ...process.env };
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  process.env.API_KEY = API_KEY;
+  process.env.APP_URL = "https://app.example.test";
+  delete process.env.SCRIPT_RUN_SUPERVISOR_DISABLE;
+  await rm(WORKFLOW_RUNTIME_DIR, { recursive: true, force: true });
+  await Bun.$`bun build ./src/script-workflows/harness.ts --target bun --no-splitting --outfile ${WORKFLOW_RUNTIME_DIR}/harness.bundle.js`.quiet();
+  process.env.SCRIPT_WORKFLOW_RUNTIME_DIR = WORKFLOW_RUNTIME_DIR;
+  refreshSecretScrubberCache();
+
+  const agent = createAgent({ name: "script-workflow-e2e-worker", isLead: false, status: "idle" });
+  agentId = agent.id;
+  server = createServer((req, res) => {
+    route(req, res).catch((err) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+    });
+  });
+  const port = await listen(server);
+  baseUrl = `http://127.0.0.1:${port}`;
+  process.env.MCP_BASE_URL = baseUrl;
+});
+
+afterAll(async () => {
+  await closeServer(server);
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+  await rm(WORKFLOW_RUNTIME_DIR, { recursive: true, force: true });
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshSecretScrubberCache();
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM script_run_journal");
+  getDb().run("DELETE FROM script_runs");
+});
+
+describe("script workflow runtime", () => {
+  test("runs a durable one-off script and replays a completed step", async () => {
+    const source = `
+      export default async function main(args, ctx) {
+        const first = await ctx.step.swarmScript("double", {
+          source: "export default async (args) => args.value * 2;",
+          args: { value: args.value },
+          intent: "script-workflow-e2e"
+        });
+        const second = await ctx.step.swarmScript("double", {
+          source: "export default async () => 999;",
+          intent: "script-workflow-e2e-should-replay"
+        });
+        return { runId: ctx.run.id, first, second };
+      }
+    `;
+
+    const created = await api("/api/script-runs", {
+      method: "POST",
+      body: JSON.stringify({ source, args: { value: 7 }, background: true }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string };
+
+    const run = await waitForRun(id);
+    expect(run.status).toBe("completed");
+    expect(run.output).toMatchObject({
+      runId: id,
+      first: { result: 14, exitCode: 0 },
+      second: { result: 14, exitCode: 0 },
+    });
+
+    const journal = listScriptRunJournalSteps(id);
+    expect(journal).toHaveLength(1);
+    expect(journal[0]?.stepKey).toBe("double");
+    expect(journal[0]?.stepType).toBe("swarm-script");
+  });
+});

package/src/tests/scripts-mcp-e2e.test.ts

@@ -6,10 +6,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { closeDb, createAgent, getDb, initDb } from "../be/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import { handleCore } from "../http/core";
+import { handleScriptRuns } from "../http/script-runs";
 import { handleScripts } from "../http/scripts";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { registerScriptDeleteTool } from "../tools/script-delete";
 import { registerScriptRunTool } from "../tools/script-run";
+import { registerScriptRunsTools } from "../tools/script-runs";
 import { registerScriptSearchTool } from "../tools/script-search";
 import { registerScriptUpsertTool } from "../tools/script-upsert";
 import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
@@ -65,6 +67,7 @@ function buildToolServer() {
   const server = new McpServer({ name: "scripts-mcp-e2e", version: "1.0.0" });
   registerScriptSearchTool(server);
   registerScriptRunTool(server);
+  registerScriptRunsTools(server);
   registerScriptUpsertTool(server);
   registerScriptDeleteTool(server);
   const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
@@ -74,6 +77,9 @@ function buildToolServer() {
     run: registered["script-run"]!,
     upsert: registered["script-upsert"]!,
     del: registered["script-delete"]!,
+    launchScriptRun: registered["launch-script-run"]!,
+    getScriptRun: registered["get-script-run"]!,
+    listScriptRuns: registered["list-script-runs"]!,
   };
 }
 
@@ -126,7 +132,10 @@ async function dispatchScriptsApi(url: string, init: RequestInit = {}): Promise<
   if (!(await handleCore(req, res, agentId, API_KEY))) {
     const pathSegments = getPathSegments(req.url || "");
     const queryParams = parseQueryParams(req.url || "");
-    if (!(await handleScripts(req, res, pathSegments, queryParams, agentId))) {
+    if (
+      !(await handleScripts(req, res, pathSegments, queryParams, agentId)) &&
+      !(await handleScriptRuns(req, res, pathSegments, queryParams, agentId))
+    ) {
       res.writeHead(404);
       res.end("Not Found");
     }
@@ -148,6 +157,7 @@ beforeAll(async () => {
   await removeDbFiles(TEST_DB_PATH);
   initDb(TEST_DB_PATH);
   process.env.AGENT_SWARM_API_KEY = API_KEY;
+  process.env.SCRIPT_RUN_SUPERVISOR_DISABLE = "true";
   delete process.env.API_KEY;
   refreshSecretScrubberCache();
   setScriptEmbeddingProviderForTests(fakeEmbeddingProvider);
@@ -155,7 +165,10 @@ beforeAll(async () => {
   process.env.MCP_BASE_URL = "http://scripts-mcp-e2e.test";
   globalThis.fetch = (async (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (url.startsWith("http://scripts-mcp-e2e.test/api/scripts/")) {
+    if (
+      url.startsWith("http://scripts-mcp-e2e.test/api/scripts/") ||
+      url.startsWith("http://scripts-mcp-e2e.test/api/script-runs")
+    ) {
       return dispatchScriptsApi(url, init);
     }
     return savedFetch(input, init);
@@ -179,6 +192,8 @@ afterAll(async () => {
 
 beforeEach(() => {
   getDb().run("DELETE FROM scripts");
+  getDb().run("DELETE FROM script_run_journal");
+  getDb().run("DELETE FROM script_runs");
 });
 
 describe("script_ MCP HTTP proxy tools", () => {
@@ -217,6 +232,59 @@ describe("script_ MCP HTTP proxy tools", () => {
     expect(del.structuredContent.data?.deleted).toBe(true);
   });
 
+  test("persists a successful inline run with kind 'inline' and no journal", async () => {
+    const tools = buildToolServer();
+    const source = `export default async (args: { value: number }) => ({ doubled: args.value * 2 });`;
+
+    const run = (await tools.run.handler(
+      { source, args: { value: 21 }, intent: "inline persist e2e" },
+      meta(workerId),
+    )) as StructuredResult<{ result: { doubled: number } }>;
+    expect(run.structuredContent.success).toBe(true);
+    expect(run.structuredContent.data?.result).toEqual({ doubled: 42 });
+
+    const listed = (await tools.listScriptRuns.handler(
+      { limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{
+      runs: Array<{ id: string; kind: string; status: string }>;
+      total: number;
+    }>;
+    expect(listed.structuredContent.data?.total).toBe(1);
+    const inlineRun = listed.structuredContent.data?.runs[0];
+    expect(inlineRun?.kind).toBe("inline");
+    expect(inlineRun?.status).toBe("completed");
+
+    const detail = (await tools.getScriptRun.handler(
+      { id: inlineRun?.id },
+      meta(workerId),
+    )) as StructuredResult<{ run: { kind: string }; journal: unknown[] }>;
+    expect(detail.structuredContent.data?.run.kind).toBe("inline");
+    expect(detail.structuredContent.data?.journal).toEqual([]);
+  });
+
+  test("persists a failed inline run with kind 'inline' and an error", async () => {
+    const tools = buildToolServer();
+    const source = `export default async () => { throw new Error("boom"); };`;
+
+    const run = (await tools.run.handler(
+      { source, intent: "inline failure e2e" },
+      meta(workerId),
+    )) as StructuredResult<unknown>;
+    expect(run.structuredContent.success).toBe(true);
+
+    const listed = (await tools.listScriptRuns.handler(
+      { limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{
+      runs: Array<{ kind: string; status: string; error?: string }>;
+    }>;
+    const failed = listed.structuredContent.data?.runs[0];
+    expect(failed?.kind).toBe("inline");
+    expect(failed?.status).toBe("failed");
+    expect(failed?.error).toBeTruthy();
+  });
+
   test("stdio-style missing agent identity short-circuits clearly", async () => {
     const tools = buildToolServer();
     const result = (await tools.search.handler({ query: "anything" }, meta())) as StructuredResult<{
@@ -226,6 +294,38 @@ describe("script_ MCP HTTP proxy tools", () => {
     expect(result.structuredContent.error).toContain("HTTP MCP transport");
   });
 
+  test("launches, lists, and inspects durable script workflow runs", async () => {
+    const tools = buildToolServer();
+    const source = `export default async function main() { return { ok: true }; }`;
+
+    const launched = (await tools.launchScriptRun.handler(
+      { source, args: { input: true }, scriptName: "mcp-script-workflow" },
+      meta(workerId),
+    )) as StructuredResult<{ id: string; status: string; url: string }>;
+    expect(launched.structuredContent.success).toBe(true);
+    expect(launched.structuredContent.status).toBe(201);
+    expect(launched.structuredContent.data?.status).toBe("running");
+    const runId = launched.structuredContent.data?.id;
+    expect(runId).toBeTruthy();
+
+    const listed = (await tools.listScriptRuns.handler(
+      { status: "running", limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{ runs: Array<{ id: string }>; total: number }>;
+    expect(listed.structuredContent.success).toBe(true);
+    expect(listed.structuredContent.data?.total).toBe(1);
+    expect(listed.structuredContent.data?.runs[0]?.id).toBe(runId);
+
+    const detail = (await tools.getScriptRun.handler(
+      { id: runId },
+      meta(workerId),
+    )) as StructuredResult<{ run: { id: string; status: string }; journal: unknown[] }>;
+    expect(detail.structuredContent.success).toBe(true);
+    expect(detail.structuredContent.data?.run.id).toBe(runId);
+    expect(detail.structuredContent.data?.run.status).toBe("running");
+    expect(detail.structuredContent.data?.journal).toEqual([]);
+  });
+
   test("typed SDK fixture passes upsert typecheck and wrong arg type fails", async () => {
     const tools = buildToolServer();
     const source = `