@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/be/scripts/typecheck.ts

@@ -50,21 +50,155 @@ export interface SwarmConfig {
 }
 
 export interface SwarmSdk {
+  // --- memory ---
   memory_search(args: { query: string; scope?: "all" | "agent" | "swarm"; limit?: number; source?: string }): Promise<unknown>;
   memory_get(args: { memoryId: string }): Promise<unknown>;
   memory_rate(args: { id: string; useful: boolean; note?: string }): Promise<unknown>;
+  // --- tasks ---
   task_list(args?: Record<string, unknown>): Promise<unknown>;
   task_get(args: { taskId: string }): Promise<unknown>;
   task_storeProgress(args: Record<string, unknown>): Promise<unknown>;
+  task_poll(args?: Record<string, unknown>): Promise<unknown>;
+  // --- kv ---
   kv_get(args: { key: string; namespace?: string }): Promise<unknown>;
   kv_set(args: { key: string; value: unknown; namespace?: string; ttlSeconds?: number; valueType?: "string" | "json" | "integer" }): Promise<unknown>;
   kv_del(args: { key: string; namespace?: string }): Promise<unknown>;
   kv_incr(args: { key: string; by?: number; namespace?: string }): Promise<unknown>;
   kv_list(args?: { prefix?: string; namespace?: string; limit?: number }): Promise<unknown>;
+  // --- repos ---
   repo_list(args?: Record<string, unknown>): Promise<unknown>;
+  // --- schedules ---
   schedule_list(args?: Record<string, unknown>): Promise<unknown>;
+  // --- scripts ---
   script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;
-  script_run(args: { name?: string; source?: string; args?: unknown; intent?: string; scope?: ScriptScope; fsMode?: ScriptFsMode }): Promise<unknown>;
+  script_run(args: { name?: string; source?: string; args?: unknown; intent?: string; scope?: ScriptScope; fsMode?: ScriptFsMode; idempotencyKey?: string }): Promise<unknown>;
+  // --- swarm / agent ---
+  swarm_get(args?: { includeFull?: boolean }): Promise<unknown>;
+  agent_info(args?: Record<string, unknown>): Promise<unknown>;
+  metrics_get(args?: Record<string, unknown>): Promise<unknown>;
+  user_resolve(args?: { kind?: string; externalId?: string; email?: string; userId?: string }): Promise<unknown>;
+  db_query(args: { sql: string; params?: unknown[] }): Promise<unknown>;
+  // --- config ---
+  config_get(args?: { agentId?: string; repoId?: string; key?: string; includeSecrets?: boolean }): Promise<unknown>;
+  config_list(args?: { scope?: "global" | "agent" | "repo"; scopeId?: string; key?: string; includeSecrets?: boolean }): Promise<unknown>;
+  // --- slack ---
+  slack_read(args?: { inboxMessageId?: string; taskId?: string; channelId?: string; threadTs?: string; limit?: number; includeFiles?: boolean }): Promise<unknown>;
+  slack_listChannels(args?: { types?: Array<"public" | "private" | "dm" | "mpim">; limit?: number }): Promise<unknown>;
+  // --- messaging ---
+  message_read(args?: { channel?: string; limit?: number; since?: string; unreadOnly?: boolean; mentionsOnly?: boolean; markAsRead?: boolean }): Promise<unknown>;
+  // --- services ---
+  service_list(args?: { agentId?: string; name?: string; status?: "starting" | "healthy" | "unhealthy" | "stopped"; includeOwn?: boolean }): Promise<unknown>;
+  // --- context / profiles ---
+  context_history(args?: { agentId?: string; field?: "soulMd" | "identityMd" | "toolsMd" | "claudeMd" | "setupScript"; limit?: number }): Promise<unknown>;
+  context_diff(args: { versionId: string; compareToVersionId?: string }): Promise<unknown>;
+  // --- workflows ---
+  workflow_list(args?: { enabled?: boolean; includeFull?: boolean }): Promise<unknown>;
+  workflow_get(args: { id: string }): Promise<unknown>;
+  workflow_listRuns(args: { workflowId: string; status?: "running" | "waiting" | "completed" | "failed" | "skipped" | "cancelled" }): Promise<unknown>;
+  workflow_getRun(args: { id: string }): Promise<unknown>;
+  // --- prompt templates ---
+  prompt_list(args?: { eventType?: string; scope?: "global" | "agent" | "repo"; scopeId?: string; isDefault?: boolean }): Promise<unknown>;
+  prompt_get(args: { id: string }): Promise<unknown>;
+  // --- tracker ---
+  tracker_status(args?: Record<string, unknown>): Promise<unknown>;
+  tracker_syncStatus(args?: Record<string, unknown>): Promise<unknown>;
+  tracker_linkTask(args: { taskId: string; externalId: string; provider?: string }): Promise<unknown>;
+  tracker_unlink(args: { taskId: string }): Promise<unknown>;
+  tracker_mapAgent(args: { agentId: string; externalId: string; provider?: string }): Promise<unknown>;
+
+  // --- write: memory ---
+  memory_delete(args: { id: string }): Promise<unknown>;
+  inject_learning(args: { content: string; name?: string; scope?: "agent" | "swarm"; source?: string; tags?: string[] }): Promise<unknown>;
+
+  // --- write: tasks ---
+  task_send(args: Record<string, unknown>): Promise<unknown>;
+  task_cancel(args: { taskId: string }): Promise<unknown>;
+  task_action(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- write: config ---
+  config_set(args: { key: string; value: unknown; scope?: "global" | "agent" | "repo"; scopeId?: string; isSecret?: boolean }): Promise<unknown>;
+  config_delete(args: { id: string }): Promise<unknown>;
+
+  // --- write: slack ---
+  slack_post(args: { channelId: string; message: string; blocks?: unknown }): Promise<unknown>;
+  slack_reply(args: { channelId?: string; threadTs?: string; message: string; taskId?: string }): Promise<unknown>;
+  slack_startThread(args: { channelId: string; message: string }): Promise<unknown>;
+  slack_uploadFile(args: Record<string, unknown>): Promise<unknown>;
+  slack_downloadFile(args: { url: string }): Promise<unknown>;
+
+  // --- write: messaging (internal) ---
+  message_post(args: { channel?: string; content: string; to?: string }): Promise<unknown>;
+
+  // --- write: profiles ---
+  profile_update(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- write: services ---
+  service_register(args: Record<string, unknown>): Promise<unknown>;
+  service_unregister(args: { name: string }): Promise<unknown>;
+  service_updateStatus(args: { name: string; status: "starting" | "healthy" | "unhealthy" | "stopped" }): Promise<unknown>;
+
+  // --- write: schedules ---
+  schedule_create(args: Record<string, unknown>): Promise<unknown>;
+  schedule_update(args: Record<string, unknown>): Promise<unknown>;
+  schedule_delete(args: { id: string }): Promise<unknown>;
+  schedule_runNow(args: { id: string }): Promise<unknown>;
+
+  // --- write: workflows ---
+  workflow_create(args: Record<string, unknown>): Promise<unknown>;
+  workflow_update(args: Record<string, unknown>): Promise<unknown>;
+  workflow_patch(args: Record<string, unknown>): Promise<unknown>;
+  workflow_patchNode(args: Record<string, unknown>): Promise<unknown>;
+  workflow_delete(args: { id: string }): Promise<unknown>;
+  workflow_trigger(args: { id: string; input?: Record<string, unknown> }): Promise<unknown>;
+  workflow_retryRun(args: { id: string }): Promise<unknown>;
+  workflow_cancelRun(args: { id: string }): Promise<unknown>;
+
+  // --- write: prompt templates ---
+  prompt_set(args: Record<string, unknown>): Promise<unknown>;
+  prompt_delete(args: { id: string }): Promise<unknown>;
+  prompt_preview(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- write: scripts ---
+  script_upsert(args: { name: string; source: string; description?: string; intent?: string; scope?: ScriptScope; fsMode?: ScriptFsMode }): Promise<unknown>;
+  script_delete(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
+  script_queryTypes(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
+  script_launchRun(args: { source: string; args?: unknown; idempotencyKey?: string; scriptName?: string; requestedByUserId?: string }): Promise<unknown>;
+  script_getRun(args: { id: string }): Promise<unknown>;
+  script_listRuns(args?: { status?: "running" | "paused" | "completed" | "failed" | "cancelled" | "aborted_limit"; agentId?: string; limit?: number; offset?: number }): Promise<unknown>;
+
+  // --- write: repos ---
+  repo_update(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- write: agent ---
+  agent_join(args: { name: string; role?: string; description?: string; capabilities?: string[]; requestedId?: string; lead?: boolean }): Promise<unknown>;
+  user_manage(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- skills ---
+  skill_list(args?: { scope?: string; scopeId?: string; includeBuiltin?: boolean }): Promise<unknown>;
+  skill_get(args: { id: string }): Promise<unknown>;
+  skill_search(args: { query: string; limit?: number }): Promise<unknown>;
+  skill_create(args: Record<string, unknown>): Promise<unknown>;
+  skill_update(args: Record<string, unknown>): Promise<unknown>;
+  skill_delete(args: { id: string }): Promise<unknown>;
+  skill_install(args: Record<string, unknown>): Promise<unknown>;
+  skill_uninstall(args: Record<string, unknown>): Promise<unknown>;
+  skill_publish(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- mcp servers ---
+  mcpServer_list(args?: Record<string, unknown>): Promise<unknown>;
+  mcpServer_get(args: { id: string }): Promise<unknown>;
+  mcpServer_create(args: Record<string, unknown>): Promise<unknown>;
+  mcpServer_update(args: Record<string, unknown>): Promise<unknown>;
+  mcpServer_delete(args: { id: string }): Promise<unknown>;
+  mcpServer_install(args: Record<string, unknown>): Promise<unknown>;
+  mcpServer_uninstall(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- pages & metrics ---
+  page_create(args: Record<string, unknown>): Promise<unknown>;
+  metric_create(args: Record<string, unknown>): Promise<unknown>;
+
+  // --- human input ---
+  request_humanInput(args: Record<string, unknown>): Promise<unknown>;
 }
 
 export interface ScriptStdlib {
@@ -78,7 +212,53 @@ export interface ScriptStdlib {
 
 export interface ScriptLogger extends Console {}
 
+export interface ScriptRunContext {
+  id: string;
+  agentId: string;
+  args: unknown;
+}
+
+export interface ScriptWorkflowSteps {
+  rawLlm(
+    label: string,
+    config: { prompt: string; model?: string; schema?: Record<string, unknown> },
+  ): Promise<unknown>;
+  agentTask(
+    label: string,
+    config: {
+      template?: string;
+      task?: string;
+      agentId?: string;
+      tags?: string[];
+      priority?: number;
+      offerMode?: boolean;
+      dir?: string;
+      vcsRepo?: string;
+      model?: string;
+      parentTaskId?: string;
+      requestedByUserId?: string;
+      outputSchema?: Record<string, unknown>;
+    },
+  ): Promise<unknown>;
+  swarmScript(
+    label: string,
+    config: {
+      name?: string;
+      scriptName?: string;
+      source?: string;
+      args?: unknown;
+      scope?: ScriptScope;
+      fsMode?: ScriptFsMode;
+      intent?: string;
+      idempotencyKey?: string;
+    },
+  ): Promise<unknown>;
+  humanInTheLoop(): Promise<never>;
+}
+
 export interface ScriptContext {
+  run?: ScriptRunContext;
+  step?: ScriptWorkflowSteps;
   swarm: SwarmSdk & { config: SwarmConfig };
   stdlib: ScriptStdlib;
   logger: ScriptLogger;

package/src/be/seed-scripts/catalog/compound-insights.ts

@@ -0,0 +1,398 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  days: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Look back this many days (default 3)"),
+  includeToolUsage: z.boolean().optional().describe("Include tool usage histogram (default true)"),
+  includeScheduleHealth: z
+    .boolean()
+    .optional()
+    .describe("Include schedule health flags (default true)"),
+  includeMemoryHealth: z.boolean().optional().describe("Include memory health stats (default true)"),
+  includeScriptCandidates: z
+    .boolean()
+    .optional()
+    .describe("Include high-frequency tool-triplet candidates for future seed scripts (default true)"),
+  includeByAgent: z
+    .boolean()
+    .optional()
+    .describe("Include per-agent task/completion/failure breakdown (default true)"),
+});
+
+/**
+ * Failure reasons that are swarm bookkeeping, not real failures. Excluded from
+ * failureClusters, scheduleHealth and byAgent failure counts (Lead Rule #16):
+ * the run engine collapses redundant sibling tasks into these statuses, so
+ * counting them produces phantom failure spikes.
+ */
+const EXCLUDED_FAIL = ["superseded_workflow_task", "cancelled"];
+
+/**
+ * `db_query` returns positional rows (`rows: unknown[][]`) plus a `columns`
+ * array — NOT an array of objects. Zip them back into objects so callers can
+ * read by column name.
+ */
+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,
+  );
+}
+
+function asNumber(value: any): number {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function round1(value: number): number {
+  return Math.round(value * 10) / 10;
+}
+
+function percent(part: number, total: number): number {
+  return total > 0 ? round1((part / total) * 100) : 0;
+}
+
+function extractToolName(content: string): string | null {
+  const match = content.match(/"type"\s*:\s*"tool_use"[\s\S]*?"name"\s*:\s*"([^"]+)"/);
+  return match?.[1] ?? null;
+}
+
+function toolSlug(tool: string): string {
+  return tool
+    .replace(/^mcp__/, "")
+    .replace(/__/g, "-")
+    .replace(/_/g, "-")
+    .replace(/[^a-zA-Z0-9-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+}
+
+function decodeFloat32Blob(value: any): Float32Array | null {
+  if (!value) return null;
+  let bytes: Uint8Array | null = null;
+  if (value instanceof Uint8Array) bytes = value;
+  else if (Array.isArray(value)) bytes = Uint8Array.from(value);
+  else if (typeof value === "object" && Array.isArray(value.data)) bytes = Uint8Array.from(value.data);
+  else if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length > 0 && keys.every((key) => /^\d+$/.test(key))) {
+      bytes = Uint8Array.from(Object.values(value) as number[]);
+    }
+  }
+  if (!bytes || bytes.byteLength < 4 || bytes.byteLength % 4 !== 0) return null;
+  return new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+}
+
+function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  const len = Math.min(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < len; i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+/**
+ * Daily compounding insights — compressed JSON for Phase 0 evolution.
+ *
+ * Swarm-wide by design: every section aggregates across ALL agents via direct
+ * read-only SQL (no per-agent scoping), so a single call replaces ~25 raw tool
+ * roundtrips. Parametric via `days` + the `include*` flags.
+ */
+export default async function compoundInsights(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args || {});
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const days = parsed.data.days || 3;
+  const includeToolUsage = parsed.data.includeToolUsage !== false;
+  const includeScheduleHealth = parsed.data.includeScheduleHealth !== false;
+  const includeMemoryHealth = parsed.data.includeMemoryHealth !== false;
+  const includeScriptCandidates = parsed.data.includeScriptCandidates !== false;
+  const includeByAgent = parsed.data.includeByAgent !== false;
+
+  // `days` is a validated positive int, so it is safe to interpolate into the
+  // SQLite datetime modifier. EXCLUDED_FAIL is a fixed constant list.
+  const w = `datetime('now','-${days} days')`;
+  const exclList = EXCLUDED_FAIL.map((r) => `'${r}'`).join(",");
+  // A "real" failure = status failed AND not one of the bookkeeping reasons.
+  const realFail = `t.status='failed' AND (t.failureReason IS NULL OR t.failureReason NOT IN (${exclList}))`;
+
+  const insights: any = { days, generatedAt: new Date().toISOString() };
+
+  // Task summary (all agents, direct SQL).
+  const statusRows = rowsToObjects(
+    await ctx.swarm.db_query({
+      sql: `SELECT status, count(*) as cnt FROM agent_tasks t WHERE t.createdAt > ${w} GROUP BY status`,
+    }),
+  );
+  const statusCounts: Record<string, number> = {};
+  let total = 0;
+  for (const r of statusRows) {
+    statusCounts[r.status] = r.cnt;
+    total += r.cnt;
+  }
+  const completed = statusCounts.completed ?? 0;
+  const failed = statusCounts.failed ?? 0;
+  insights.taskSummary = {
+    total,
+    completed,
+    failed,
+    completionRate: total > 0 ? Math.round((completed / total) * 1000) / 10 : 0,
+    failureRate: total > 0 ? Math.round((failed / total) * 1000) / 10 : 0,
+    statusCounts,
+  };
+
+  // Failure clusters (real failures only, normalized to a 60-char lowercased prefix).
+  insights.failureClusters = rowsToObjects(
+    await ctx.swarm.db_query({
+      sql: `SELECT substr(lower(t.failureReason),1,60) as reason, count(*) as count
+            FROM agent_tasks t
+            WHERE ${realFail} AND t.failureReason IS NOT NULL AND t.createdAt > ${w}
+            GROUP BY reason ORDER BY count DESC LIMIT 10`,
+    }),
+  );
+
+  // Schedule health (>= 2 runs, > 20% real-failure rate).
+  if (includeScheduleHealth) {
+    const sh = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT s.name as name, s.id as id, count(t.id) as runs,
+                     sum(case when ${realFail} then 1 else 0 end) as failed
+              FROM scheduled_tasks s
+              JOIN agent_tasks t ON t.scheduleId = s.id
+              WHERE t.createdAt > ${w} AND t.status != 'cancelled'
+              GROUP BY s.id, s.name HAVING runs >= 2`,
+      }),
+    );
+    insights.scheduleHealth = sh
+      .map((r: any) => ({
+        name: r.name,
+        id: r.id,
+        runs: r.runs,
+        failureRate: r.runs > 0 ? Math.round((r.failed / r.runs) * 100) : 0,
+      }))
+      .filter((r: any) => r.failureRate > 20)
+      .sort((a: any, b: any) => b.failureRate - a.failureRate);
+  }
+
+  // Tool usage (top 25). Tool names live inside the `content` JSON of
+  // session_logs (no dedicated column), so extract the name SQL-side: the
+  // `'%"type":"tool_use"%'` filter excludes tool_result rows (which only carry
+  // `tool_use_id`), and instr/substr pull the first tool name per log line.
+  // Approximate: a log line with parallel tool_use blocks counts only its first.
+  if (includeToolUsage) {
+    insights.toolUsage = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `WITH tu AS (
+                 SELECT substr(content, instr(content,'"type":"tool_use"')) AS tail
+                 FROM session_logs
+                 WHERE content LIKE '%"type":"tool_use"%' AND createdAt > ${w}
+               ),
+               nm AS (
+                 SELECT substr(tail, instr(tail,'"name":"')+8) AS rest
+                 FROM tu WHERE instr(tail,'"name":"') > 0
+               )
+               SELECT substr(rest,1,instr(rest,'"')-1) AS tool, count(*) AS calls
+               FROM nm GROUP BY tool ORDER BY calls DESC LIMIT 25`,
+      }),
+    ).map((r: any) => ({ tool: r.tool, calls: r.calls }));
+  }
+
+  // Memory health (whole store, by scope + source). Pollution markers are
+  // SQL-light counts plus JS-side embedding similarity where available; prod
+  // SQLite does not expose a scalar cosine_similarity() function.
+  if (includeMemoryHealth) {
+    const memRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT scope, source, count(*) as cnt,
+                     sum(case when accessCount = 0 then 1 else 0 end) as zeroAccess,
+                     sum(case when sourceTaskId IS NOT NULL OR sourcePath IS NOT NULL then 1 else 0 end) as referenced
+              FROM agent_memory GROUP BY scope, source`,
+      }),
+    );
+    const totalMem = memRows.reduce((s: number, r: any) => s + (r.cnt ?? 0), 0);
+    const bySource: any = {};
+    for (const r of memRows) {
+      bySource[r.source] ??= {
+        total: 0,
+        percentOfStore: 0,
+        zeroAccess: 0,
+        zeroAccessPercent: 0,
+        referenced: 0,
+      };
+      bySource[r.source].total += asNumber(r.cnt);
+      bySource[r.source].zeroAccess += asNumber(r.zeroAccess);
+      bySource[r.source].referenced += asNumber(r.referenced);
+    }
+    for (const source of Object.keys(bySource)) {
+      bySource[source].percentOfStore = percent(bySource[source].total, totalMem);
+      bySource[source].zeroAccessPercent = percent(bySource[source].zeroAccess, bySource[source].total);
+    }
+
+    const autoSnapshotSources = ["session_summary", "task_completion"];
+    const autoSnapshotTotal = autoSnapshotSources.reduce(
+      (sum, source) => sum + (bySource[source]?.total ?? 0),
+      0,
+    );
+    const popularButUseless = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT id, name, source, accessCount, alpha, beta,
+                     round(alpha / nullif(alpha + beta, 0), 3) as usefulness,
+                     substr(content, 1, 180) as preview
+              FROM agent_memory
+              WHERE source IN ('session_summary','task_completion')
+                AND accessCount >= 5
+                AND alpha <= beta
+              ORDER BY accessCount DESC, beta DESC LIMIT 10`,
+      }),
+    ).map((r: any) => ({
+      id: r.id,
+      name: r.name,
+      source: r.source,
+      accessCount: asNumber(r.accessCount),
+      usefulness: Number(r.usefulness ?? 0),
+      preview: r.preview,
+    }));
+    const zeroAccessStaleRefRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT source, count(*) as count
+              FROM agent_memory
+              WHERE accessCount = 0
+                AND (sourceTaskId IS NOT NULL OR sourcePath IS NOT NULL)
+                AND createdAt < datetime('now','-${days} days')
+              GROUP BY source ORDER BY count DESC`,
+      }),
+    );
+
+    const similarityRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT id, name, source, accessCount, embedding
+              FROM agent_memory
+              WHERE source IN ('session_summary','task_completion')
+                AND embedding IS NOT NULL
+              ORDER BY accessCount DESC LIMIT 30`,
+      }),
+    );
+    let strongestAutoSnapshotPair: any = null;
+    const vectors = similarityRows
+      .map((r: any) => ({ ...r, vector: decodeFloat32Blob(r.embedding) }))
+      .filter((r: any) => r.vector);
+    for (let i = 0; i < vectors.length; i++) {
+      for (let j = i + 1; j < vectors.length; j++) {
+        const similarity = cosineSimilarity(vectors[i].vector, vectors[j].vector);
+        if (!strongestAutoSnapshotPair || similarity > strongestAutoSnapshotPair.similarity) {
+          strongestAutoSnapshotPair = {
+            similarity: round1(similarity * 100) / 100,
+            a: { id: vectors[i].id, name: vectors[i].name, source: vectors[i].source },
+            b: { id: vectors[j].id, name: vectors[j].name, source: vectors[j].source },
+          };
+        }
+      }
+    }
+
+    insights.memoryHealth = {
+      total: totalMem,
+      byScope: memRows.reduce((m: any, r: any) => {
+        m[r.scope] = (m[r.scope] ?? 0) + r.cnt;
+        return m;
+      }, {}),
+      bySource,
+      pollution: {
+        autoSnapshotSources,
+        autoSnapshotTotal,
+        autoSnapshotPercent: percent(autoSnapshotTotal, totalMem),
+        popularButUselessAutoSnapshots: popularButUseless,
+        zeroAccessStaleRefs: {
+          total: zeroAccessStaleRefRows.reduce((sum: number, r: any) => sum + asNumber(r.count), 0),
+          bySource: zeroAccessStaleRefRows.reduce((m: any, r: any) => {
+            m[r.source] = asNumber(r.count);
+            return m;
+          }, {}),
+        },
+        similarityCheck: {
+          sqliteCosineSimilarityAvailable: false,
+          path: "js",
+          sampledAutoSnapshots: vectors.length,
+          strongestAutoSnapshotPair,
+        },
+      },
+    };
+  }
+
+  // Evolution/self-scripting candidates: high-frequency consecutive tool
+  // triplets are good prompts for a future seed script.
+  if (includeScriptCandidates) {
+    const rows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `WITH raw AS (
+                 SELECT sessionId, iteration, lineNumber, content,
+                        json_extract(content, '$.tool_name') as jsonToolName
+                 FROM session_logs
+                 WHERE createdAt > ${w}
+                   AND (content LIKE '%"type":"tool_use"%' OR json_extract(content, '$.tool_name') IS NOT NULL)
+               )
+               SELECT sessionId, iteration, lineNumber, jsonToolName, content
+               FROM raw ORDER BY sessionId, iteration, lineNumber LIMIT 100`,
+      }),
+    );
+    const bySession = new Map<string, string[]>();
+    for (const row of rows) {
+      const tool = row.jsonToolName || extractToolName(String(row.content ?? ""));
+      if (!tool) continue;
+      const key = String(row.sessionId ?? "unknown");
+      const tools = bySession.get(key) ?? [];
+      tools.push(tool);
+      bySession.set(key, tools);
+    }
+    const counts = new Map<string, { tools: string[]; count: number }>();
+    for (const tools of bySession.values()) {
+      for (let i = 0; i <= tools.length - 3; i++) {
+        const triplet = tools.slice(i, i + 3);
+        const key = triplet.join(" -> ");
+        const current = counts.get(key) ?? { tools: triplet, count: 0 };
+        current.count += 1;
+        counts.set(key, current);
+      }
+    }
+    insights.scriptCandidates = [...counts.values()]
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10)
+      .map((r) => ({
+        tools: r.tools,
+        count: r.count,
+        suggestedName: r.tools.map(toolSlug).filter(Boolean).slice(0, 3).join("-").slice(0, 80),
+      }));
+  }
+
+  // Per-agent breakdown — covers every agent that ran a task in the window.
+  if (includeByAgent) {
+    insights.byAgent = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT a.name as agent, count(*) as total,
+                     sum(case when t.status='completed' then 1 else 0 end) as completed,
+                     sum(case when ${realFail} then 1 else 0 end) as failed
+              FROM agent_tasks t LEFT JOIN agents a ON a.id = t.agentId
+              WHERE t.createdAt > ${w} AND t.agentId IS NOT NULL
+              GROUP BY t.agentId, a.name ORDER BY total DESC LIMIT 30`,
+      }),
+    ).map((r: any) => ({
+      agent: r.agent,
+      total: r.total,
+      completed: r.completed,
+      failed: r.failed,
+    }));
+  }
+
+  return insights;
+}