@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/be/seed-scripts/catalog/schedule-health.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  days: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Look back this many days (default 7)"),
+  failureThreshold: z
+    .number()
+    .optional()
+    .describe("Flag schedules with failure rate above this (0-1, default 0.2)"),
+});
+
+/** Per-schedule health check: failure rates and flagging unhealthy schedules. */
+export default async function scheduleHealth(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args);
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const days = parsed.data.days || 7;
+  const threshold = parsed.data.failureThreshold ?? 0.2;
+  const since = new Date(Date.now() - days * 86400000).toISOString();
+
+  // Get schedules
+  const schedRes: any = await ctx.swarm.schedule_list({});
+  const schedPayload = schedRes?.data ?? schedRes;
+  const schedules: any[] = schedPayload?.schedules ?? [];
+
+  if (!schedules.length) return { days, schedules: [], flagged: [] };
+
+  // Get recent tasks to correlate with schedules
+  const taskRes: any = await ctx.swarm.task_list({ createdAfter: since, limit: 2000 });
+  const taskPayload = taskRes?.data ?? taskRes;
+  const tasks: any[] = taskPayload?.tasks ?? [];
+
+  // Group by scheduleId
+  const bySchedule = new Map<string, { total: number; failed: number; completed: number }>();
+  for (const t of tasks) {
+    if (!t.scheduleId) continue;
+    const entry = bySchedule.get(t.scheduleId) ?? { total: 0, failed: 0, completed: 0 };
+    entry.total++;
+    if (t.status === "failed") entry.failed++;
+    if (t.status === "completed") entry.completed++;
+    bySchedule.set(t.scheduleId, entry);
+  }
+
+  const results = schedules.map((s: any) => {
+    const stats = bySchedule.get(s.id) ?? { total: 0, failed: 0, completed: 0 };
+    const failureRate = stats.total > 0 ? stats.failed / stats.total : 0;
+    return {
+      id: s.id,
+      name: s.name,
+      enabled: s.enabled,
+      targetAgentId: s.targetAgentId,
+      runs: stats.total,
+      failed: stats.failed,
+      completed: stats.completed,
+      failureRate: Math.round(failureRate * 1000) / 1000,
+      flagged: stats.total >= 3 && failureRate > threshold,
+    };
+  });
+
+  const flagged = results.filter((r: any) => r.flagged);
+
+  return {
+    days,
+    threshold,
+    totalSchedules: schedules.length,
+    flaggedCount: flagged.length,
+    schedules: results.sort((a: any, b: any) => b.failureRate - a.failureRate),
+    flagged,
+  };
+}

package/src/be/seed-scripts/catalog/smart-recall.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  queries: z
+    .array(z.string())
+    .min(1)
+    .describe("One or more search queries to fan out against the memory store"),
+  scope: z
+    .enum(["all", "agent", "swarm"])
+    .optional()
+    .describe("Memory scope filter (default all)"),
+  limit: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Max results per query (default 10)"),
+  dedupThreshold: z
+    .number()
+    .optional()
+    .describe("Similarity threshold for dedup — memories above this are merged (default 0.92)"),
+});
+
+/** Multi-query fan-out memory recall with dedup and composite reranking. */
+export default async function smartRecall(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args);
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const { queries, scope = "all", limit = 10, dedupThreshold = 0.92 } = parsed.data;
+
+  const allResults: any[] = [];
+  for (const q of queries) {
+    const res: any = await ctx.swarm.memory_search({ query: q, limit, scope });
+    const payload = res?.data ?? res;
+    const results = payload?.results ?? [];
+    for (const r of results) {
+      allResults.push({ ...r, querySource: q });
+    }
+  }
+
+  // Dedup by ID, keeping best similarity per memory
+  const seen = new Map<string, any>();
+  const hitCounts = new Map<string, number>();
+  for (const r of allResults) {
+    hitCounts.set(r.id, (hitCounts.get(r.id) ?? 0) + 1);
+    const existing = seen.get(r.id);
+    if (!existing || r.similarity > existing.similarity) {
+      seen.set(r.id, r);
+    }
+  }
+
+  // Composite rerank: bestSimilarity + 0.05 * hitCount
+  const deduped = Array.from(seen.values()).map((r) => ({
+    ...r,
+    hits: hitCounts.get(r.id) ?? 1,
+    compositeScore: r.similarity + 0.05 * (hitCounts.get(r.id) ?? 1),
+  }));
+  deduped.sort((a: any, b: any) => b.compositeScore - a.compositeScore);
+
+  return {
+    queriesRun: queries.length,
+    totalCandidates: allResults.length,
+    uniqueMemories: deduped.length,
+    memories: deduped.slice(0, limit * 2),
+  };
+}

package/src/be/seed-scripts/catalog/task-context-gathering.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  taskId: z.string().describe("Task ID to fetch details for"),
+  queries: z
+    .array(z.string())
+    .min(1)
+    .describe("Search queries from the task description — 2-4 recommended"),
+  scope: z
+    .enum(["all", "agent", "swarm"])
+    .optional()
+    .describe("Memory scope filter (default all)"),
+  memoryLimit: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Max memories per query before dedup (default 8)"),
+});
+
+function slimTask(task: any) {
+  if (!task || typeof task !== "object") return null;
+  return {
+    id: task.id,
+    status: task.status,
+    description: task.task,
+    dependsOn: task.dependsOn,
+    slackChannelId: task.slackChannelId,
+    slackThreadTs: task.slackThreadTs,
+    createdAt: task.createdAt,
+    finishedAt: task.finishedAt,
+    agentId: task.agentId,
+    output: task.output,
+    failureReason: task.failureReason,
+  };
+}
+
+/** Fetch slim task details plus deduped multi-query memories for task onboarding. */
+export default async function taskContextGathering(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args);
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const { taskId, queries, scope = "all", memoryLimit = 8 } = parsed.data;
+
+  const taskRes: any = await ctx.swarm.task_get({ taskId });
+  const taskPayload = taskRes?.data ?? taskRes;
+  if (taskPayload?.success === false) {
+    return { error: taskPayload.message ?? "task_get failed", taskId };
+  }
+
+  const allResults: any[] = [];
+  for (const query of queries) {
+    const res: any = await ctx.swarm.memory_search({ query, scope, limit: memoryLimit });
+    const payload = res?.data ?? res;
+    const results = payload?.results ?? [];
+    for (const memory of results) {
+      allResults.push({ ...memory, querySource: query });
+    }
+  }
+
+  const byId = new Map<string, any>();
+  const hitCounts = new Map<string, number>();
+  for (const memory of allResults) {
+    const id = typeof memory.id === "string" ? memory.id : JSON.stringify(memory);
+    hitCounts.set(id, (hitCounts.get(id) ?? 0) + 1);
+    const existing = byId.get(id);
+    const similarity = typeof memory.similarity === "number" ? memory.similarity : 0;
+    const existingSimilarity =
+      existing && typeof existing.similarity === "number" ? existing.similarity : -Infinity;
+    if (!existing || similarity > existingSimilarity) byId.set(id, memory);
+  }
+
+  const memories = Array.from(byId.entries()).map(([id, memory]) => {
+    const hits = hitCounts.get(id) ?? 1;
+    const similarity = typeof memory.similarity === "number" ? memory.similarity : 0;
+    return {
+      ...memory,
+      hits,
+      compositeScore: similarity + 0.05 * hits,
+    };
+  });
+  memories.sort((a: any, b: any) => b.compositeScore - a.compositeScore);
+
+  return {
+    task: slimTask(taskPayload?.task),
+    requestedBy: taskPayload?.requestedBy,
+    attachments: taskPayload?.attachments ?? [],
+    queriesRun: queries.length,
+    totalCandidates: allResults.length,
+    uniqueMemories: memories.length,
+    memories: memories.slice(0, memoryLimit * 2),
+  };
+}

package/src/be/seed-scripts/catalog/tool-usage.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  days: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Look back this many days (default 7)"),
+  agentId: z.string().optional().describe("Filter by agent ID (default: all agents)"),
+  limit: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Top N tools to return (default 20)"),
+});
+
+/** Tool usage histogram from session_logs — top tools by call count. */
+export default async function toolUsage(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args);
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const days = parsed.data.days || 7;
+  const limit = parsed.data.limit || 20;
+  const agentId = parsed.data.agentId;
+
+  const agentFilter = agentId ? `AND agent_id = '${agentId}'` : "";
+  const sql = `
+    SELECT tool_name, count(*) as calls
+    FROM session_logs
+    WHERE tool_name IS NOT NULL
+      AND created_at > datetime('now', '-${days} days')
+      ${agentFilter}
+    GROUP BY tool_name
+    ORDER BY calls DESC
+    LIMIT ${limit}
+  `;
+
+  const res: any = await ctx.swarm.db_query({ sql });
+  const payload = res?.data ?? res;
+  const columns: string[] = payload?.columns ?? [];
+  const rows: any[] = (payload?.rows ?? []).map((row: any[]) =>
+    Object.fromEntries(columns.map((column, index) => [column, row[index]])),
+  );
+
+  const totalCalls = rows.reduce((sum: number, r: any) => sum + (r.calls ?? 0), 0);
+
+  return {
+    days,
+    agentId: agentId ?? "all",
+    totalDistinctTools: rows.length,
+    totalCalls,
+    tools: rows.map((r: any) => ({
+      tool: r.tool_name,
+      calls: r.calls,
+      pct: totalCalls > 0 ? Math.round((r.calls / totalCalls) * 1000) / 10 : 0,
+    })),
+  };
+}

package/src/be/seed-scripts/index.ts

@@ -22,6 +22,7 @@ import { getScript, upsertScriptByName } from "../scripts/db";
 import { extractArgsJsonSchema } from "../scripts/extract-schema";
 import { typecheckScript } from "../scripts/typecheck";
 import type { Seeder, SeedItem } from "../seed/types";
+import compoundInsightsSrc from "./catalog/compound-insights.ts" with { type: "text" };
 import dateResolveSrc from "./catalog/date-resolve.ts" with { type: "text" };
 import fetchReadableSrc from "./catalog/fetch-readable.ts" with { type: "text" };
 import ghPrSnapshotSrc from "./catalog/gh-pr-snapshot.ts" with { type: "text" };
@@ -29,9 +30,14 @@ import groupCountSrc from "./catalog/group-count.ts" with { type: "text" };
 import jsonQuerySrc from "./catalog/json-query.ts" with { type: "text" };
 import linearIssueSrc from "./catalog/linear-issue.ts" with { type: "text" };
 import memoryDedupCheckSrc from "./catalog/memory-dedup-check.ts" with { type: "text" };
+import opsCatalogAuditSrc from "./catalog/ops-catalog-audit.ts" with { type: "text" };
+import scheduleHealthSrc from "./catalog/schedule-health.ts" with { type: "text" };
 import slackThreadFlattenSrc from "./catalog/slack-thread-flatten.ts" with { type: "text" };
+import smartRecallSrc from "./catalog/smart-recall.ts" with { type: "text" };
+import taskContextGatheringSrc from "./catalog/task-context-gathering.ts" with { type: "text" };
 import taskFailureAuditSrc from "./catalog/task-failure-audit.ts" with { type: "text" };
 import textDiffSrc from "./catalog/text-diff.ts" with { type: "text" };
+import toolUsageSrc from "./catalog/tool-usage.ts" with { type: "text" };
 
 export type SeedScript = {
   name: string;
@@ -122,6 +128,54 @@ export const SEED_SCRIPTS: SeedScript[] = [
     intent: "Turn a Slack thread into plain text for summarizing or as task context.",
     source: asText(slackThreadFlattenSrc),
   },
+  {
+    name: "smart-recall",
+    description:
+      "Multi-query fan-out memory search with dedup and composite reranking (bestSimilarity + 0.05 * hitCount). Returns unique memories across all queries.",
+    intent:
+      "Recall relevant memories using multiple search angles — better coverage than a single query. Use for task onboarding, context gathering, or before writing new memories.",
+    source: asText(smartRecallSrc),
+  },
+  {
+    name: "task-context-gathering",
+    description:
+      "Get task details and recall relevant memories in one call — returns a slimmed task projection plus deduped and reranked memories from multi-query fan-out.",
+    intent:
+      "Task onboarding: one call instead of task_get plus multiple memory_search calls. Pass the task description split into 2-4 natural-language queries.",
+    source: asText(taskContextGatheringSrc),
+  },
+  {
+    name: "schedule-health",
+    description:
+      "Per-schedule failure rate check over recent tasks — flags schedules with failure rates above a configurable threshold.",
+    intent:
+      "Find unhealthy schedules that keep failing — for daily compounding, reliability reviews, or ops triage.",
+    source: asText(scheduleHealthSrc),
+  },
+  {
+    name: "tool-usage",
+    description:
+      "Tool usage histogram from session_logs — top tools by call count over a time window, optionally filtered by agent.",
+    intent:
+      "See which MCP tools agents use most — for SDK gap analysis, optimization, or daily ops snapshots.",
+    source: asText(toolUsageSrc),
+  },
+  {
+    name: "compound-insights",
+    description:
+      "All-in-one swarm-wide daily ops snapshot: task completion/failure summary, real failure clusters (excludes superseded/cancelled bookkeeping), schedule health flags, tool usage top-25, memory health/pollution stats, seed-script candidate tool triplets, and a per-agent breakdown. Aggregates across ALL agents via direct read-only SQL.",
+    intent:
+      "Single-call daily compounding Phase 0 helper — replaces ~25 raw tool roundtrips with one compressed JSON result covering every agent. For daily evolution, self-scripting candidates, ops reviews, or heartbeat context.",
+    source: asText(compoundInsightsSrc),
+  },
+  {
+    name: "ops-catalog-audit",
+    description:
+      "Audit-as-code catalog check for schedules, workflows, and prompt/template drift. Clusters actionable findings by goal and can publish an authed HTML report page.",
+    intent:
+      "Re-run the ops inventory audit in one call: duplicate/dead schedules, code-work routing risks, enabled workflow fixtures, structured-output gate gaps, prompt registry drift, stale hosts, and systemDefault skill duplicates.",
+    source: asText(opsCatalogAuditSrc),
+  },
 ];
 
 /** A catalog entry resolved into a generic {@link SeedItem}. */

package/src/be/seed-skills/index.ts

@@ -31,6 +31,12 @@ import scheduledTaskResilienceConfig from "../../../templates/skills/scheduled-t
 import scheduledTaskResilienceContent from "../../../templates/skills/scheduled-task-resilience/content.md" with {
   type: "text",
 };
+import scriptWorkflowsConfig from "../../../templates/skills/script-workflows/config.json" with {
+  type: "text",
+};
+import scriptWorkflowsContent from "../../../templates/skills/script-workflows/content.md" with {
+  type: "text",
+};
 import swarmScriptsConfig from "../../../templates/skills/swarm-scripts/config.json" with {
   type: "text",
 };
@@ -72,6 +78,7 @@ const BUILT_IN_SKILL_SOURCES = [
   { config: kvStorageConfig, body: kvStorageContent },
   { config: pagesConfig, body: pagesContent },
   { config: scheduledTaskResilienceConfig, body: scheduledTaskResilienceContent },
+  { config: scriptWorkflowsConfig, body: scriptWorkflowsContent },
   { config: swarmScriptsConfig, body: swarmScriptsContent },
   { config: workflowIterateConfig, body: workflowIterateContent },
   { config: workflowStructuredOutputConfig, body: workflowStructuredOutputContent },

package/src/be/swarm-config-guard.ts

@@ -41,6 +41,23 @@ const VALIDATED_KEYS: Record<string, (value: unknown) => string | null> = {
     if (parsed.success) return null;
     return `Invalid HARNESS_PROVIDER value (must be one of: ${ProviderNameSchema.options.join(", ")})`;
   },
+  // Codex credits-exhausted cooldown (ms). Permissive on range here (positive
+  // integer) — the worker clamps to [5m, 7d] via resolveCodexCreditsExhaustedCooldownMs.
+  CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS: (value) => {
+    const str = String(value).trim();
+    if (!/^\d+$/.test(str) || Number(str) <= 0) {
+      return "Invalid CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS (must be a positive integer of milliseconds)";
+    }
+    return null;
+  },
+  SWARM_USE_CLAUDE_BRIDGE: (value) => {
+    if (typeof value !== "string") {
+      return "Invalid SWARM_USE_CLAUDE_BRIDGE value (must be one of: true, false, 1, 0)";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["true", "false", "1", "0"].includes(normalized)) return null;
+    return "Invalid SWARM_USE_CLAUDE_BRIDGE value (must be one of: true, false, 1, 0)";
+  },
 };
 
 export function validateConfigValue(key: string, value: unknown): string | null {

package/src/commands/artifact.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { createArtifactServer } from "../artifact-sdk";
 import { getApiKey } from "../utils/api-key";
+import { getMcpBaseUrl } from "../utils/constants";
 
 interface ArtifactArgs {
   additionalArgs: string[];
@@ -139,7 +140,7 @@ async function artifactServe(args: ArtifactArgs) {
 
 async function artifactList() {
   const apiKey = getApiKey();
-  const mcpBaseUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+  const mcpBaseUrl = getMcpBaseUrl();
   const agentId = process.env.AGENT_ID || "";
 
   try {
@@ -197,7 +198,7 @@ async function artifactStop(args: ArtifactArgs) {
   }
 
   const apiKey = getApiKey();
-  const mcpBaseUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+  const mcpBaseUrl = getMcpBaseUrl();
   const agentId = process.env.AGENT_ID || "";
 
   // 1. Try to stop PM2 process