@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/workflows/executors/raw-llm.ts

@@ -16,6 +16,76 @@ export const RawLlmOutputSchema = z.object({
   model: z.string(),
 });
 
+export async function executeRawLlm(
+  config: z.infer<typeof RawLlmConfigSchema>,
+): Promise<
+  | { status: "success"; output: z.infer<typeof RawLlmOutputSchema>; error?: string }
+  | { status: "failed"; error: string }
+> {
+  const modelName = config.model ?? "google/gemini-3-flash-preview";
+
+  try {
+    const { createOpenAI } = await import("@ai-sdk/openai");
+    const openrouter = createOpenAI({
+      baseURL: "https://openrouter.ai/api/v1",
+      apiKey: process.env.OPENROUTER_API_KEY,
+    });
+    const model = openrouter(modelName);
+
+    if (config.schema) {
+      const { generateObject, jsonSchema } = await import("ai");
+      const { object } = await generateObject({
+        model,
+        schema: jsonSchema(config.schema),
+        prompt: config.prompt,
+        providerOptions: {
+          openai: { strictJsonSchema: false },
+        },
+      });
+      return {
+        status: "success",
+        output: { result: object, model: modelName },
+      };
+    }
+
+    const { generateText } = await import("ai");
+    const { text } = await generateText({
+      model,
+      prompt: config.prompt,
+    });
+    return {
+      status: "success",
+      output: { result: text, model: modelName },
+    };
+  } catch (err) {
+    // Re-throw rate-limit errors so executeStep's retry policy handles them
+    // via the retry poller (scheduled backoff). Using the fallbackPort for
+    // rate limits would trigger the semantic loop-back path instead, causing
+    // runaway retries without any backoff.
+    const httpStatus =
+      (err as { status?: number; statusCode?: number })?.status ??
+      (err as { status?: number; statusCode?: number })?.statusCode;
+    const isRateLimited =
+      httpStatus === 429 ||
+      httpStatus === 529 ||
+      (err instanceof Error && /rate.?limit|too many requests|529/i.test(err.message));
+    if (isRateLimited) {
+      throw err;
+    }
+    if (config.fallbackPort) {
+      return {
+        status: "success",
+        output: { result: null, model: modelName },
+        error: `LLM call failed, using fallback port: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+    return {
+      status: "failed",
+      error: `LLM call failed: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
 // ─── Executor ───────────────────────────────────────────────
 
 export class RawLlmExecutor extends BaseExecutor<
@@ -33,68 +103,15 @@ export class RawLlmExecutor extends BaseExecutor<
     _meta: ExecutorMeta,
   ): Promise<ExecutorResult<z.infer<typeof RawLlmOutputSchema>>> {
     const prompt = this.deps.interpolate(config.prompt, context as Record<string, unknown>);
-    const modelName = config.model ?? "google/gemini-3-flash-preview";
-
-    try {
-      const { createOpenAI } = await import("@ai-sdk/openai");
-      const openrouter = createOpenAI({
-        baseURL: "https://openrouter.ai/api/v1",
-        apiKey: process.env.OPENROUTER_API_KEY,
-      });
-      const model = openrouter(modelName);
-
-      if (config.schema) {
-        const { generateObject, jsonSchema } = await import("ai");
-        const { object } = await generateObject({
-          model,
-          schema: jsonSchema(config.schema),
-          prompt,
-          providerOptions: {
-            openai: { strictJsonSchema: false },
-          },
-        });
-        return {
-          status: "success",
-          output: { result: object, model: modelName },
-        };
-      }
-
-      const { generateText } = await import("ai");
-      const { text } = await generateText({
-        model,
-        prompt,
-      });
+    const result = await executeRawLlm({ ...config, prompt });
+    if (result.status === "success" && result.error) {
       return {
         status: "success",
-        output: { result: text, model: modelName },
-      };
-    } catch (err) {
-      // Re-throw rate-limit errors so executeStep's retry policy handles them
-      // via the retry poller (scheduled backoff). Using the fallbackPort for
-      // rate limits would trigger the semantic loop-back path instead, causing
-      // runaway retries without any backoff.
-      const httpStatus =
-        (err as { status?: number; statusCode?: number })?.status ??
-        (err as { status?: number; statusCode?: number })?.statusCode;
-      const isRateLimited =
-        httpStatus === 429 ||
-        httpStatus === 529 ||
-        (err instanceof Error && /rate.?limit|too many requests|529/i.test(err.message));
-      if (isRateLimited) {
-        throw err;
-      }
-      if (config.fallbackPort) {
-        return {
-          status: "success",
-          output: { result: null, model: modelName },
-          nextPort: config.fallbackPort,
-          error: `LLM call failed, using fallback port: ${err instanceof Error ? err.message : String(err)}`,
-        };
-      }
-      return {
-        status: "failed",
-        error: `LLM call failed: ${err instanceof Error ? err.message : String(err)}`,
+        output: result.output,
+        nextPort: config.fallbackPort,
+        error: result.error,
       };
     }
+    return result;
   }
 }

package/templates/skills/pages/content.md

@@ -1,85 +1,235 @@
 # Pages
 
-Pages are persistent, shareable HTML documents created via the swarm's `create_page` MCP tool. Use them when the output benefits from layout, tables, headers, and persistent sharing — unlike Slack messages, pages don't expire and can be bookmarked.
+Pages are persistent, shareable HTML documents created via the swarm's page tooling. Use them when the output benefits from layout, tables, headers, and persistent sharing. A page should be a clean human-facing report, not a raw dump with a URL.
+
+This skill covers both how to publish and how to design the page. It distills the current external design guidance from Anthropic's `frontend-design`, Vercel's `composition-patterns`, and Vercel's `web-design-guidelines`: start from content hierarchy, use a small spacing system, keep typography readable, prefer restraint over decoration, and make responsive behavior intentional.
 
 ## When to Create a Page
 
 - A report, dashboard, or summary that benefits from structured layout
 - Analysis that should be linkable and bookmarkable
-- Results that need to be reviewed asynchronously (not in a Slack thread)
-- Content that's too long or rich for a `store-progress.output` string
+- Results that need to be reviewed asynchronously
+- Content that is too long or rich for a `store-progress.output` string
 
 Do NOT use pages for:
-- In-flight progress notes (use `store-progress.progress`)
-- Sensitive data (credentials, private customer data)
-- Large binary files (use agent-fs for PNG/MP4)
+
+- In-flight progress notes; use `store-progress.progress`
+- Secrets, private credentials, or unapproved personal data
+- Large binary files; use agent-fs for PNG/MP4
+- Raw verbose logs; summarize them and link to artifacts
+
+## Page Design Defaults
+
+Every page should be useful at a glance.
+
+- Put the page's point in the first viewport: title, one-sentence summary, and 3-6 key numbers or statuses.
+- Use a single-column reading spine with `max-width: 1120px`; keep prose measure around 65-75 characters.
+- Use system fonts unless there is a clear reason not to: `Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`.
+- Use a restrained palette: neutral background, high-contrast text, white panels, one accent color, and semantic colors for statuses only.
+- Use a consistent spacing scale: `8, 12, 16, 24, 32, 48, 72`.
+- Use clear type hierarchy: page title 36-48px desktop / 30-36px mobile, section titles 22-28px, body 15-16px, supporting text 13-14px.
+- Keep tables readable: sticky/scannable headers where useful, padded cells, zebra-free or very subtle row borders, `tabular-nums` for numbers, horizontal scroll on narrow screens.
+- Prefer cards only for repeated records or metrics. Do not nest cards inside cards.
+- Hide raw JSON behind a collapsed `<details>` block at the bottom.
+- Make mobile explicit with media queries: single-column grids, reduced padding, no overflow except intentional table scroll.
+
+## Content Structure
+
+Use this order unless the task gives a better domain-specific structure:
+
+1. Hero: title, short summary, timestamp/source context
+2. Key metrics: 3-6 tiles that answer "how big / how bad / what changed?"
+3. Findings or sections grouped by theme, owner, severity, or stage
+4. Evidence tables or samples under each finding
+5. Next actions or recommendations
+6. Raw evidence links / collapsed JSON appendix
+
+Write section headings as labels, not slogans. Favor "Critical Routing Gaps" over "Things We Found".
 
 ## Creating a Page
 
+Use the page tool with an HTML body. Prefer `contentType: "text/html"` and an explicit `authMode` for internal reports.
+
 ```javascript
-// Via MCP tool
-create_page({
-  title: "Q2 SEO Performance Report",
-  content: `<h1>Q2 SEO Performance</h1>
-<p>Analysis period: 2026-04-01 to 2026-06-30</p>
-<h2>Summary</h2>
-<table>
-  <tr><th>Metric</th><th>Q1</th><th>Q2</th><th>Change</th></tr>
-  <tr><td>Organic clicks</td><td>12,400</td><td>18,600</td><td>+50%</td></tr>
-</table>
-<h2>Next Actions</h2>
-<ul>
-  <li>Publish 3 new pillar pages targeting high-intent queries</li>
-  <li>Fix 23 pages with missing meta descriptions</li>
-</ul>`
-})
+const html = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Q2 SEO Performance</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #f6f4f0;
+      --panel: #ffffff;
+      --ink: #18181b;
+      --muted: #62646a;
+      --line: #dedbd2;
+      --accent: #2563eb;
+      --danger: #b42318;
+      --warn: #b54708;
+      --ok: #067647;
+      --radius: 8px;
+      --shadow: 0 1px 2px rgba(24, 24, 27, 0.06), 0 12px 32px rgba(24, 24, 27, 0.07);
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--bg);
+      color: var(--ink);
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      font-size: 16px;
+      line-height: 1.55;
+    }
+    main {
+      width: min(1120px, calc(100% - 32px));
+      margin: 0 auto;
+      padding: 48px 0 72px;
+    }
+    header { margin-bottom: 32px; }
+    .eyebrow {
+      margin: 0 0 8px;
+      color: var(--muted);
+      font-size: 13px;
+      font-weight: 700;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+    h1 {
+      margin: 0;
+      max-width: 780px;
+      font-size: clamp(2rem, 4vw, 3rem);
+      line-height: 1.05;
+      letter-spacing: 0;
+    }
+    .lede {
+      max-width: 760px;
+      margin: 16px 0 0;
+      color: var(--muted);
+      font-size: 18px;
+    }
+    .metrics {
+      display: grid;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      gap: 12px;
+      margin: 32px 0;
+    }
+    .metric, .section {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: var(--radius);
+      box-shadow: var(--shadow);
+    }
+    .metric { padding: 18px; }
+    .metric strong {
+      display: block;
+      font-size: 32px;
+      line-height: 1;
+      font-variant-numeric: tabular-nums;
+    }
+    .metric span {
+      display: block;
+      margin-top: 8px;
+      color: var(--muted);
+      font-size: 13px;
+      font-weight: 650;
+    }
+    .section {
+      margin-top: 18px;
+      padding: 24px;
+    }
+    h2 { margin: 0 0 12px; font-size: 24px; line-height: 1.2; }
+    h3 { margin: 0 0 8px; font-size: 17px; line-height: 1.3; }
+    p { margin: 0 0 12px; }
+    .table-wrap { overflow-x: auto; border: 1px solid var(--line); border-radius: var(--radius); }
+    table { width: 100%; border-collapse: collapse; min-width: 640px; }
+    th, td { padding: 10px 12px; border-bottom: 1px solid var(--line); text-align: left; vertical-align: top; }
+    th { color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: 0.06em; }
+    td { font-size: 14px; }
+    code, pre { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+    details { margin-top: 24px; }
+    summary { cursor: pointer; font-weight: 700; }
+    pre { overflow: auto; padding: 16px; background: #111827; color: #f9fafb; border-radius: var(--radius); }
+    @media (max-width: 760px) {
+      main { width: min(100% - 24px, 1120px); padding-top: 32px; }
+      .metrics { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+      .section { padding: 18px; }
+    }
+    @media (max-width: 520px) {
+      .metrics { grid-template-columns: 1fr; }
+      .lede { font-size: 16px; }
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <header>
+      <p class="eyebrow">Generated 2026-06-04</p>
+      <h1>Q2 SEO Performance</h1>
+      <p class="lede">Organic traffic grew sharply, but the next gains depend on fixing thin page metadata and publishing three high-intent pillar pages.</p>
+    </header>
+
+    <section class="metrics" aria-label="Key metrics">
+      <div class="metric"><strong>18.6k</strong><span>Organic clicks</span></div>
+      <div class="metric"><strong>+50%</strong><span>Quarter over quarter</span></div>
+      <div class="metric"><strong>23</strong><span>Metadata fixes</span></div>
+      <div class="metric"><strong>3</strong><span>Priority pages</span></div>
+    </section>
+
+    <section class="section">
+      <h2>Summary</h2>
+      <p>Start with the conclusion. Add tables only after the reader understands what changed and what to do next.</p>
+      <div class="table-wrap">
+        <table>
+          <thead><tr><th>Metric</th><th>Q1</th><th>Q2</th><th>Change</th></tr></thead>
+          <tbody><tr><td>Organic clicks</td><td>12,400</td><td>18,600</td><td>+50%</td></tr></tbody>
+        </table>
+      </div>
+    </section>
+  </main>
+</body>
+</html>`;
+
+await create_page({
+  title: "Q2 SEO Performance",
+  slug: "q2-seo-performance",
+  description: "Human-readable SEO performance report with summary metrics and next actions.",
+  contentType: "text/html",
+  authMode: "authed",
+  body: html,
+});
 ```
 
-Returns a page ID. Build the share URL:
-```
+Returns a page ID. Build share URLs from environment:
+
+```text
 ${APP_URL}/pages/<pageId>           # opens in SPA with chrome
 ${APP_URL}/pages/<pageId>?mode=full # slim header, full viewport
-${MCP_BASE_URL}/p/<pageId>          # direct HTML (no SPA)
+${MCP_BASE_URL}/p/<pageId>          # direct HTML
 ```
 
-Read `APP_URL` and `MCP_BASE_URL` from environment — never hardcode.
+Read `APP_URL` and `MCP_BASE_URL` from environment. Never hardcode localhost or example hosts in shared output.
 
-## Content Guidelines
+## Design Checklist
 
-**Keep raw evidence in artifacts and link to it.** The page should contain:
-1. **Short summary** (1 paragraph) — what this covers and the key finding
-2. **Source links** — links to the data, agent-fs artifacts, or upstream systems
-3. **Structured content** — tables, headers, numbered lists
-4. **Next actions** — what should happen next, who owns it
+Before publishing:
 
-Do NOT embed:
-- Secrets or private credentials
-- Personal data of individuals without approval
-- Raw verbose logs (summarize them)
+- The first viewport states what the page is, why it matters, and the key numbers.
+- The page has a clear hierarchy: `h1`, short lede, metrics, sections, evidence.
+- Body text is readable on mobile and desktop.
+- Tables scroll horizontally on mobile instead of crushing columns.
+- Status colors are semantic and not the whole visual identity.
+- Raw JSON/logs are collapsed or linked, not the primary experience.
+- No nested cards, decorative gradients, oversized hero art, or cramped default browser styles.
+- No text overlaps, clipped buttons, or unreadable low-contrast text.
 
-## Page vs. Agent-fs
+## Page vs Agent-fs
 
 | Use pages for | Use agent-fs for |
 |---|---|
 | Reports, dashboards, human-readable summaries | Markdown research notes, code files, recordings |
 | Content that benefits from HTML layout | Searchable knowledge base entries |
-| Quick share links to non-technical stakeholders | Binary artifacts (PNG, MP4) |
+| Quick share links to non-technical stakeholders | Binary artifacts such as PNG or MP4 |
 | Time-bounded deliverables | Long-lived reference documentation |
 
-## Sharing Pages
-
-Always use the platform share URL (from `APP_URL` env var) rather than hardcoded local hosts. Append `?mode=full` for a standalone view (hides sidebar/header — good for screenshots or embedding in Slack previews).
-
-```bash
-# Get the share URL
-PAGE_URL="${APP_URL}/pages/${pageId}?mode=full"
-
-# Post to Slack
-slack-reply --taskId <id> --message "Report ready: ${PAGE_URL}"
-```
-
-## Trade-offs
-
-**Pages vs Slack messages:** Slack messages are ephemeral and scroll out of view. Pages are persistent and bookmarkable. Use pages for anything you'd want to reference in 3 months; use Slack for in-the-moment communication.
-
-**Pages vs agent-fs:** Pages are rendered HTML with a share URL — great for non-technical stakeholders. Agent-fs files are raw content — great for other agents and developers who need the source data. For a research memo, write the source to agent-fs and create a page for the human-facing summary.
+For a research memo, write the source to agent-fs and create a page for the human-facing summary.

package/templates/skills/script-workflows/config.json

@@ -0,0 +1,14 @@
+{
+  "kind": "skill",
+  "name": "script-workflows",
+  "displayName": "Script Workflows",
+  "slug": "script-workflows",
+  "title": "Script Workflows",
+  "description": "Launch and inspect durable one-off script workflow runs with journaled swarm-script, raw-llm, and agent-task steps.",
+  "version": "1.0.0",
+  "category": "skills",
+  "placeholders": [],
+  "runAllSeedersCandidate": true,
+  "systemDefault": true,
+  "tags": ["scripts", "workflows", "automation"]
+}

package/templates/skills/script-workflows/content.md

@@ -0,0 +1,68 @@
+Use this skill when a user asks to launch, monitor, inspect, or debug a durable script workflow run. This is for the Script Workflows v1 runtime: one-off TypeScript workflow source with journaled `swarm-script`, `raw-llm`, and `agent-task` steps.
+
+## Tool Flow
+
+Load the script workflow tools with ToolSearch when they are not already visible:
+
+```text
+launch-script-run
+get-script-run
+list-script-runs
+```
+
+Use `launch-script-run` to start a one-off run. It calls the same `/api/script-runs` API as the dashboard, preserves the invoking agent identity, and starts the run in the background.
+
+Use `get-script-run` to read terminal status and journal entries. Poll it when needed, but keep polling bounded and report progress for long runs.
+
+Use `list-script-runs` to find recent runs or filter by `status` / `agentId`.
+
+Do not hand-roll raw HTTP for this flow unless the tool itself is broken and you are explicitly debugging the API. The tool handles auth and `X-Agent-ID` like the existing inline `script-run` tool family.
+
+## Source Shape
+
+Author TypeScript workflow source as a default export. The runtime provides `args` and `ctx`.
+
+```ts
+export default async function main(args, ctx) {
+  const lookup = await ctx.step.swarmScript("lookup-data", {
+    scriptName: "fetch-readable",
+    args: { url: args.url },
+  });
+
+  const summary = await ctx.step.rawLlm("summarize", {
+    prompt: `Summarize this for an operator:\n${JSON.stringify(lookup)}`,
+  });
+
+  const task = await ctx.step.agentTask("operator-review", {
+    task: `Review this summary and flag risks:\n${JSON.stringify(summary)}`,
+    tags: ["script-run"],
+    priority: 50,
+  });
+
+  return { lookup, summary, task };
+}
+```
+
+## Label Rules
+
+Step labels are durability keys. They must be stable and unique for each logical step. Do not reuse the same literal label inside a loop; launch will fail with `label_lint_violation`.
+
+For looped work, include an item identifier in the label:
+
+```ts
+for (const item of args.items) {
+  await ctx.step.agentTask(`review-${item.id}`, { task: item.prompt });
+}
+```
+
+## Statuses
+
+Terminal statuses to surface clearly:
+
+- `completed` — run finished and `output` may be present.
+- `failed` — run ended with `error`.
+- `cancelled` — run was cancelled before completion.
+- `aborted_limit` — runtime guardrail stopped the run, usually step count, agent-task count, or wall-clock cap.
+- `label_lint_violation` — launch-time rejection, not a persisted run status.
+
+When a run is not terminal, report the current status, journal count, and latest heartbeat if present.

package/templates/skills/swarm-scripts/content.md

@@ -32,16 +32,18 @@ Use `script-query-types` before non-trivial work so the script matches the live
 Use `script-run` with inline source for one-off work:
 
 ```typescript
-export default async function main(args: { status: string; limit: number }, ctx) {
+export default async function main(args: any, ctx: any) {
   const { swarm, logger } = ctx;
-  const result = await swarm.task_list({ status: args.status, limit: args.limit });
-  logger.info(`Fetched ${result.tasks.length} tasks`);
+  // All SDK methods return Promise<unknown> — unwrap defensively.
+  const res: any = await swarm.task_list({ status: args?.status, limit: args?.limit ?? 50 });
+  const tasks: any[] = res?.data?.tasks ?? res?.tasks ?? [];
+  logger.info(`Fetched ${tasks.length} tasks`);
   return {
-    total: result.tasks.length,
-    tasks: result.tasks.map((task) => ({
+    total: tasks.length,
+    tasks: tasks.map((task: any) => ({
       id: task.id,
       status: task.status,
-      title: task.task.slice(0, 120),
+      title: task.task?.slice(0, 120),
     })),
   };
 }
@@ -60,8 +62,44 @@ Good named scripts:
 - Fan out over many swarm tasks, memories, repos, or schedules.
 - Convert noisy JSON or HTML into a compact summary.
 
+## Using `db_query` For Aggregation
+
+For scripts that aggregate over tasks, sessions, or memory, `ctx.swarm.db_query` with direct SQL is far more efficient than fetching lists client-side.
+
+**The parameter is `sql`:**
+
+```typescript
+// CORRECT
+const res = await ctx.swarm.db_query({ sql: "SELECT status, count(*) as cnt FROM agent_tasks GROUP BY status" });
+
+// Legacy scripts may still run with `query`, but new code should not use it.
+```
+
+**`db_query` returns positional rows, not objects.** The response shape is `{ rows: unknown[][], columns: string[] }`. Zip them into objects:
+
+```typescript
+function rowsToObjects(res: any): any[] {
+  const p = res?.data ?? res;
+  const cols: string[] = p?.columns ?? [];
+  return (p?.rows ?? []).map((r: any) =>
+    Array.isArray(r) ? Object.fromEntries(cols.map((c, i) => [c, r[i]])) : r,
+  );
+}
+
+const rows = rowsToObjects(await ctx.swarm.db_query({
+  sql: `SELECT status, count(*) as cnt FROM agent_tasks WHERE createdAt > datetime('now','-3 days') GROUP BY status`,
+}));
+// rows = [{ status: "completed", cnt: 42 }, ...]
+```
+
+**Common tables:** `agent_tasks` (tasks), `session_logs` (tool call logs), `agent_memory` (memories), `scheduled_tasks` (schedules), `agents` (agent registry).
+
+**`session_logs` has no `tool_name` column.** Tool names are embedded in the `content` JSON column. Extract them SQL-side with `instr`/`substr` or parse JSON in JS after fetching.
+
 ## SDK And Context Gotchas
 
+- **`args` can be undefined.** When a script is called without arguments, `args` is `undefined`. Always guard: `argsSchema.safeParse(args || {})` or use optional chaining (`args?.field`).
+- **All SDK methods return `Promise<unknown>`.** Never assume a specific return shape without defensive unwrapping (`res?.data?.tasks ?? res?.tasks ?? []`). Run `script-query-types` to see live type signatures — return types are `unknown` and actual shapes vary by endpoint.
 - `agentId` is propagated to scripts via the `X-Agent-ID` header, so SDK calls run as the invoking agent.
 - `taskId` is not ambient. If a script needs to call `ctx.swarm.task_storeProgress`, pass `taskId` explicitly in `args`.
 - Scripts invoked from a workflow script node may run with a workflow identity rather than a human or worker agent identity.
@@ -73,7 +111,7 @@ Good named scripts:
 Thread task identity explicitly:
 
 ```typescript
-export default async function main(args: { taskId: string; items: string[] }, ctx) {
+export default async function main(args: { taskId: string; items: string[] }, ctx: any) {
   const { swarm } = ctx;
   await swarm.task_storeProgress({
     taskId: args.taskId,