@desplega.ai/agent-swarm 1.92.1 → 1.92.2

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

@@ -18,6 +18,14 @@ export const argsSchema = z.object({
     .boolean()
     .optional()
     .describe("Include high-frequency tool-triplet candidates for future seed scripts (default true)"),
+  includeScriptUsage: z
+    .boolean()
+    .optional()
+    .describe("Include actual script run, creation, and edit metrics (default true)"),
+  includeCostAndTokens: z
+    .boolean()
+    .optional()
+    .describe("Include session cost and token metrics with honesty rails (default true)"),
   includeByAgent: z
     .boolean()
     .optional()
@@ -59,6 +67,17 @@ function percent(part: number, total: number): number {
   return total > 0 ? round1((part / total) * 100) : 0;
 }
 
+function round4(value: number): number {
+  return Math.round(value * 10000) / 10000;
+}
+
+function percentile(values: number[], p: number): number | null {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, Math.min(sorted.length - 1, index))] ?? null;
+}
+
 function extractToolName(content: string): string | null {
   const match = content.match(/"type"\s*:\s*"tool_use"[\s\S]*?"name"\s*:\s*"([^"]+)"/);
   return match?.[1] ?? null;
@@ -106,6 +125,220 @@ function cosineSimilarity(a: Float32Array, b: Float32Array): number {
   return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
 
+function summarizeScriptUsage(rows: any[], creationRows: any[], editRows: any[], toolRows: any[]) {
+  const terminalStatuses = new Set(["completed", "failed", "cancelled", "aborted_limit"]);
+  const failureStatuses = new Set(["failed", "cancelled", "aborted_limit"]);
+  const durations = rows
+    .map((r) => asNumber(r.durationMs))
+    .filter((duration) => duration > 0);
+  const byScript = new Map<
+    string,
+    {
+      scriptName: string;
+      runs: number;
+      completed: number;
+      failed: number;
+      successRate: number;
+      durationP50Ms: number | null;
+      durationP95Ms: number | null;
+      inline: number;
+      workflow: number;
+      durations: number[];
+    }
+  >();
+
+  for (const row of rows) {
+    const name = String(row.scriptName || "(inline source)");
+    const current =
+      byScript.get(name) ??
+      {
+        scriptName: name,
+        runs: 0,
+        completed: 0,
+        failed: 0,
+        successRate: 0,
+        durationP50Ms: null,
+        durationP95Ms: null,
+        inline: 0,
+        workflow: 0,
+        durations: [],
+      };
+    current.runs += 1;
+    if (row.kind === "inline") current.inline += 1;
+    if (row.kind === "workflow") current.workflow += 1;
+    if (row.status === "completed") current.completed += 1;
+    if (failureStatuses.has(String(row.status))) current.failed += 1;
+    const duration = asNumber(row.durationMs);
+    if (duration > 0) current.durations.push(duration);
+    byScript.set(name, current);
+  }
+
+  const perScript = [...byScript.values()]
+    .map((script) => ({
+      scriptName: script.scriptName,
+      runs: script.runs,
+      completed: script.completed,
+      failed: script.failed,
+      successRate: percent(script.completed, script.runs),
+      durationP50Ms: percentile(script.durations, 50),
+      durationP95Ms: percentile(script.durations, 95),
+      inline: script.inline,
+      workflow: script.workflow,
+    }))
+    .sort((a, b) => b.runs - a.runs)
+    .slice(0, 20);
+
+  const creationsByScope: Record<string, number> = {};
+  let creations = 0;
+  let scratchCreations = 0;
+  for (const row of creationRows) {
+    const count = asNumber(row.count);
+    if (asNumber(row.isScratch) === 1) {
+      scratchCreations += count;
+    } else {
+      creations += count;
+      creationsByScope[String(row.scope || "unknown")] =
+        (creationsByScope[String(row.scope || "unknown")] ?? 0) + count;
+    }
+  }
+
+  const editsByScope: Record<string, number> = {};
+  let edits = 0;
+  for (const row of editRows) {
+    const count = asNumber(row.count);
+    edits += count;
+    editsByScope[String(row.scope || "unknown")] =
+      (editsByScope[String(row.scope || "unknown")] ?? 0) + count;
+  }
+
+  return {
+    source: {
+      authoritativeRuns: "script_runs",
+      mcpCallSignal: "session_logs tool_use for script tools",
+      reconciliation:
+        "`script-run` via MCP calls /api/scripts/run, which records kind='inline' rows in script_runs; launch-script-run/workflows record kind='workflow'. session_logs counts agent tool calls and must not be added to script_runs totals.",
+    },
+    runs: {
+      total: rows.length,
+      inline: rows.filter((r) => r.kind === "inline").length,
+      workflow: rows.filter((r) => r.kind === "workflow").length,
+      completed: rows.filter((r) => r.status === "completed").length,
+      failed: rows.filter((r) => failureStatuses.has(String(r.status))).length,
+      runningOrPaused: rows.filter((r) => !terminalStatuses.has(String(r.status))).length,
+      successRate: percent(
+        rows.filter((r) => r.status === "completed").length,
+        rows.length,
+      ),
+      durationP50Ms: percentile(durations, 50),
+      durationP95Ms: percentile(durations, 95),
+      perScript,
+    },
+    creations: {
+      totalNonScratch: creations,
+      scratch: scratchCreations,
+      byScope: creationsByScope,
+    },
+    edits: {
+      total: edits,
+      byScope: editsByScope,
+    },
+    mcpToolCalls: toolRows.map((r) => ({ tool: r.tool, calls: asNumber(r.calls) })),
+  };
+}
+
+function summarizeCostAndTokens(rows: any[]) {
+  const trustedSources = new Set(["harness", "pricing-table"]);
+  const trustedRows = rows.filter((r) => trustedSources.has(String(r.costSource)));
+  const unpricedRows = rows.filter((r) => String(r.costSource) === "unpriced");
+  const trustedTaskRows = trustedRows.filter((r) => r.taskId);
+  const trustedTaskIds = new Set(trustedTaskRows.map((r) => String(r.taskId)));
+  const trustedTaskSpend = trustedTaskRows.reduce((sum, r) => sum + asNumber(r.totalCostUsd), 0);
+  const nonTaskRows = rows.filter((r) => !r.taskId);
+  const totalSpend = rows.reduce((sum, r) => sum + asNumber(r.totalCostUsd), 0);
+  const trustedSpend = trustedRows.reduce((sum, r) => sum + asNumber(r.totalCostUsd), 0);
+
+  const sumToken = (field: string) =>
+    rows.reduce((sum, r) => (r[field] === null || r[field] === undefined ? sum : sum + asNumber(r[field])), 0);
+  const unknownCount = (field: string) =>
+    rows.filter((r) => r[field] === null || r[field] === undefined).length;
+
+  const groupBy = (field: string) => {
+    const grouped = new Map<
+      string,
+      {
+        key: string;
+        rows: number;
+        spendUsd: number;
+        trustedSpendUsd: number;
+        unpricedRows: number;
+      }
+    >();
+    for (const row of rows) {
+      const key = String(row[field] || "unknown");
+      const current =
+        grouped.get(key) ?? {
+          key,
+          rows: 0,
+          spendUsd: 0,
+          trustedSpendUsd: 0,
+          unpricedRows: 0,
+        };
+      current.rows += 1;
+      current.spendUsd += asNumber(row.totalCostUsd);
+      if (trustedSources.has(String(row.costSource))) current.trustedSpendUsd += asNumber(row.totalCostUsd);
+      if (String(row.costSource) === "unpriced") current.unpricedRows += 1;
+      grouped.set(key, current);
+    }
+    return [...grouped.values()]
+      .map((r) => ({
+        ...r,
+        spendUsd: round4(r.spendUsd),
+        trustedSpendUsd: round4(r.trustedSpendUsd),
+      }))
+      .sort((a, b) => b.spendUsd - a.spendUsd);
+  };
+
+  return {
+    source: {
+      table: "session_costs",
+      providerDerivation:
+        "provider is derived from agents.harness_provider, then agents.provider, because session_costs does not carry a provider column",
+      headlineAvgCostRule:
+        "avgCostPerTaskUsd excludes unpriced rows and rows with null taskId; null-task sessions are reported separately",
+    },
+    rows: rows.length,
+    taskCountForHeadlineAvg: trustedTaskIds.size,
+    avgCostPerTaskUsd:
+      trustedTaskIds.size > 0 ? round4(trustedTaskSpend / trustedTaskIds.size) : null,
+    totalSpendUsd: round4(totalSpend),
+    trustedSpendUsd: round4(trustedSpend),
+    trustedRows: trustedRows.length,
+    trustedRowPercent: percent(trustedRows.length, rows.length),
+    unpricedRows: unpricedRows.length,
+    unpricedSpendUsd: round4(unpricedRows.reduce((sum, r) => sum + asNumber(r.totalCostUsd), 0)),
+    nonTaskSessionRows: nonTaskRows.length,
+    nonTaskSessionSpendUsd: round4(
+      nonTaskRows.reduce((sum, r) => sum + asNumber(r.totalCostUsd), 0),
+    ),
+    tokenTotals: {
+      inputTokens: sumToken("inputTokens"),
+      outputTokens: sumToken("outputTokens"),
+      cacheReadTokens: sumToken("cacheReadTokens"),
+      cacheWriteTokens: sumToken("cacheWriteTokens"),
+      reasoningOutputTokens: sumToken("reasoningOutputTokens"),
+      thinkingTokens: sumToken("thinkingTokens"),
+    },
+    unknownCounts: {
+      cacheWriteTokens: unknownCount("cacheWriteTokens"),
+      numTurns: unknownCount("numTurns"),
+    },
+    byModel: groupBy("model"),
+    byAgent: groupBy("agentName"),
+    byProvider: groupBy("provider"),
+    byCostSource: groupBy("costSource"),
+  };
+}
+
 /**
  * Daily compounding insights — compressed JSON for Phase 0 evolution.
  *
@@ -121,6 +354,8 @@ export default async function compoundInsights(args: any, ctx: any) {
   const includeScheduleHealth = parsed.data.includeScheduleHealth !== false;
   const includeMemoryHealth = parsed.data.includeMemoryHealth !== false;
   const includeScriptCandidates = parsed.data.includeScriptCandidates !== false;
+  const includeScriptUsage = parsed.data.includeScriptUsage !== false;
+  const includeCostAndTokens = parsed.data.includeCostAndTokens !== false;
   const includeByAgent = parsed.data.includeByAgent !== false;
   const publishPage = parsed.data.publishPage !== false;
 
@@ -378,6 +613,101 @@ export default async function compoundInsights(args: any, ctx: any) {
       }));
   }
 
+  // Actual script usage. Authoritative run counts come from `script_runs`;
+  // session_logs tool_use rows are a separate MCP-call signal for reconciliation
+  // and are intentionally not added to run totals.
+  if (includeScriptUsage) {
+    const runRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `WITH journal_durations AS (
+                 SELECT runId, sum(durationMs) AS journalDurationMs
+                 FROM script_run_journal
+                 WHERE durationMs IS NOT NULL
+                 GROUP BY runId
+               )
+               SELECT sr.scriptName, sr.kind, sr.status, sr.startedAt, sr.finishedAt,
+                      COALESCE(
+                        jd.journalDurationMs,
+                        CASE
+                          WHEN sr.finishedAt IS NOT NULL
+                          THEN CAST((julianday(sr.finishedAt) - julianday(sr.startedAt)) * 86400000 AS INTEGER)
+                          ELSE NULL
+                        END
+                      ) AS durationMs
+               FROM script_runs sr
+               LEFT JOIN journal_durations jd ON jd.runId = sr.id
+               WHERE sr.startedAt > ${w}
+               ORDER BY sr.startedAt DESC`,
+      }),
+    );
+    const creationRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT scope, isScratch, count(*) AS count
+              FROM scripts
+              WHERE createdAt > ${w}
+              GROUP BY scope, isScratch`,
+      }),
+    );
+    const editRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT s.scope, count(*) AS count
+              FROM script_versions sv
+              JOIN scripts s ON s.id = sv.scriptId
+              WHERE sv.changedAt > ${w} AND sv.version > 1
+              GROUP BY s.scope`,
+      }),
+    );
+    const scriptToolRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `WITH tu AS (
+                 SELECT substr(content, instr(content,'"type":"tool_use"')) AS tail,
+                        json_extract(content, '$.tool_name') as jsonToolName
+                 FROM session_logs
+                 WHERE createdAt > ${w}
+                   AND (content LIKE '%script-run%'
+                     OR content LIKE '%launch-script-run%'
+                     OR content LIKE '%get-script-run%'
+                     OR content LIKE '%list-script-runs%')
+               ),
+               nm AS (
+                 SELECT COALESCE(
+                          jsonToolName,
+                          CASE
+                            WHEN instr(tail,'"name":"') > 0
+                            THEN substr(substr(tail, instr(tail,'"name":"')+8), 1, instr(substr(tail, instr(tail,'"name":"')+8), '"')-1)
+                            ELSE NULL
+                          END
+                        ) AS tool
+                 FROM tu
+               )
+               SELECT tool, count(*) AS calls
+               FROM nm
+               WHERE tool IS NOT NULL AND tool LIKE '%script%'
+               GROUP BY tool
+               ORDER BY calls DESC`,
+      }),
+    );
+    insights.scriptUsage = summarizeScriptUsage(runRows, creationRows, editRows, scriptToolRows);
+  }
+
+  // Cost and token accounting. `costSource='unpriced'` rows are excluded from
+  // the headline per-task average, and null taskId rows are reported separately.
+  if (includeCostAndTokens) {
+    const costRows = rowsToObjects(
+      await ctx.swarm.db_query({
+        sql: `SELECT sc.taskId, sc.agentId, COALESCE(a.name, sc.agentId, 'unknown') AS agentName,
+                     COALESCE(a.harness_provider, a.provider, 'unknown') AS provider,
+                     sc.totalCostUsd, sc.inputTokens, sc.outputTokens, sc.cacheReadTokens,
+                     sc.cacheWriteTokens, sc.reasoningOutputTokens, sc.thinkingTokens,
+                     sc.numTurns, sc.model, sc.costSource
+              FROM session_costs sc
+              LEFT JOIN agents a ON a.id = sc.agentId
+              WHERE sc.createdAt > ${w}`,
+      }),
+    );
+    insights.costAndTokens = summarizeCostAndTokens(costRows);
+  }
+
   // Per-agent breakdown — covers every agent that ran a task in the window.
   if (includeByAgent) {
     insights.byAgent = rowsToObjects(
@@ -431,6 +761,31 @@ export default async function compoundInsights(args: any, ctx: any) {
       action: "Consider turning this repeated workflow into a reusable seeded script.",
       samples: [candidate],
     }));
+    const scriptUsageFindings = insights.scriptUsage
+      ? [
+          {
+            id: "script-usage.actual-runs",
+            severity: "low",
+            summary: `${insights.scriptUsage.runs.total} actual script run(s): ${insights.scriptUsage.runs.inline} one-off, ${insights.scriptUsage.runs.workflow} recurring/workflow.`,
+            action: "Use script_runs as the authoritative run count; use session_logs only as an MCP-call reconciliation signal.",
+            samples: [insights.scriptUsage],
+          },
+        ]
+      : [];
+    const costFindings = insights.costAndTokens
+      ? [
+          {
+            id: "cost-and-tokens.headline",
+            severity:
+              insights.costAndTokens.unpricedRows > 0 || insights.costAndTokens.nonTaskSessionRows > 0
+                ? "medium"
+                : "low",
+            summary: `$${insights.costAndTokens.totalSpendUsd} total session spend; avg task cost $${insights.costAndTokens.avgCostPerTaskUsd ?? "n/a"} over trusted task rows.`,
+            action: "Keep unpriced and null-task session spend separate from the headline per-task average.",
+            samples: [insights.costAndTokens],
+          },
+        ]
+      : [];
 
     insights.page = await publishCatalogReportPage(
       {
@@ -444,6 +799,8 @@ export default async function compoundInsights(args: any, ctx: any) {
           ["Completed", insights.taskSummary.completed],
           ["Failed", insights.taskSummary.failed],
           ["Failure clusters", insights.failureClusters?.length || 0],
+          ["Script runs", insights.scriptUsage?.runs?.total ?? 0],
+          ["Total spend", insights.costAndTokens?.totalSpendUsd ?? 0],
         ],
         sections: [
           {
@@ -481,6 +838,20 @@ export default async function compoundInsights(args: any, ctx: any) {
             checks: { candidates: scriptFindings.length },
             findings: scriptFindings,
           },
+          {
+            key: "script-usage",
+            goal: "Track actual one-off and recurring script execution without double-counting MCP tool-use logs.",
+            findingCount: scriptUsageFindings.length,
+            checks: insights.scriptUsage ?? {},
+            findings: scriptUsageFindings,
+          },
+          {
+            key: "cost-and-tokens",
+            goal: "Track per-task cost and token consumption while separating unpriced and non-task sessions.",
+            findingCount: costFindings.length,
+            checks: insights.costAndTokens ?? {},
+            findings: costFindings,
+          },
         ],
         appendix: insights,
       },

package/src/http/index.ts

@@ -556,6 +556,15 @@ httpServer
 
     // Start expired-memory garbage collector (1-hour tick, immediate first run)
     startMemoryGc();
+
+    // Background backfill: re-embed any agent_memory rows with wrong-dimension
+    // embeddings (e.g. 1536d instead of 512d). Non-blocking, idempotent, no-op
+    // when the DB is clean. See src/be/memory/boot-reembed.ts.
+    import("../be/memory/boot-reembed")
+      .then(({ runBootReembed }) => runBootReembed())
+      .catch((err) => {
+        console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
+      });
   })
   .on("error", (err) => {
     console.error("HTTP Server Error:", err);

package/src/http/memory.ts

@@ -387,6 +387,8 @@ export async function handleMemory(
           name: r.name,
           content: r.content,
           similarity: r.similarity,
+          rawSimilarity: r.rawSimilarity,
+          compositeScore: r.compositeScore,
           source: r.source,
           scope: r.scope,
         })),
@@ -442,6 +444,8 @@ export async function handleMemory(
             scope: r.scope,
             source: r.source,
             similarity: r.similarity,
+            rawSimilarity: r.rawSimilarity,
+            compositeScore: r.compositeScore,
             createdAt: r.createdAt,
             accessedAt: r.accessedAt,
             accessCount: r.accessCount ?? 0,

package/src/tasks/worker-follow-up.ts

@@ -2,6 +2,7 @@ import {
   createTaskExtended,
   getActiveTaskCount,
   getAgentById,
+  getDependentTasks,
   getLeadAgent,
   getTaskAttachments,
   getTaskById,
@@ -115,6 +116,17 @@ export function createWorkerTaskFollowUp(args: {
       task_id: task.id,
     });
     followUpDescription = failedResult.text;
+
+    // Enrich with cascade info: list dependents that were cascade-failed.
+    const cascadedDeps = getDependentTasks(task.id, { includeTerminal: true }).filter(
+      (t) => t.status === "failed" && t.failureReason?.includes("Blocked dependency"),
+    );
+    if (cascadedDeps.length > 0) {
+      const depLines = cascadedDeps.map(
+        (d) => `- ${d.id.slice(0, 8)} — "${d.task.slice(0, 100)}" (${d.failureReason})`,
+      );
+      followUpDescription += `\n\n⚠️ Cascade impact: ${cascadedDeps.length} dependent task(s) were also failed because they depend on this task:\n${depLines.join("\n")}`;
+    }
   }
 
   return createTaskExtended(followUpDescription, {

package/src/tests/memory-e2e.test.ts

@@ -123,13 +123,13 @@ describe("Memory E2E Lifecycle", () => {
 
   describe("reranking affects result order", () => {
     test("newer memory with same embedding ranks higher", () => {
-      // Create old memory
+      // Use task_completion source so recency decay applies (manual has no decay)
       const old = store.store({
         agentId: agentA,
         scope: "agent",
         name: "old knowledge",
         content: "Old deployment docs",
-        source: "manual",
+        source: "task_completion",
       });
       store.updateEmbedding(old.id, new Float32Array([0.5, 0.5, 0.0]), "test-model");
 
@@ -144,7 +144,7 @@ describe("Memory E2E Lifecycle", () => {
         scope: "agent",
         name: "fresh knowledge",
         content: "New deployment docs",
-        source: "manual",
+        source: "task_completion",
       });
       store.updateEmbedding(fresh.id, new Float32Array([0.5, 0.5, 0.0]), "test-model");
 
@@ -302,7 +302,7 @@ describe("Memory E2E Lifecycle", () => {
         content: "Agent A only",
         source: "manual",
       });
-      store.updateEmbedding(m1.id, new Float32Array([1, 0, 0]), "test-model");
+      store.updateEmbedding(m1.id, new Float32Array([1, 0.3, 0.3]), "test-model");
       agentMemId = m1.id;
 
       const m2 = store.store({
@@ -312,7 +312,7 @@ describe("Memory E2E Lifecycle", () => {
         content: "Visible to all",
         source: "manual",
       });
-      store.updateEmbedding(m2.id, new Float32Array([0, 1, 0]), "test-model");
+      store.updateEmbedding(m2.id, new Float32Array([0.3, 1, 0.3]), "test-model");
       swarmMemId = m2.id;
 
       const m3 = store.store({
@@ -322,7 +322,7 @@ describe("Memory E2E Lifecycle", () => {
         content: "Agent B only",
         source: "manual",
       });
-      store.updateEmbedding(m3.id, new Float32Array([0, 0, 1]), "test-model");
+      store.updateEmbedding(m3.id, new Float32Array([0.3, 0.3, 1]), "test-model");
       otherAgentMemId = m3.id;
     });
 

package/src/tests/memory-rater-e2e.test.ts

@@ -558,13 +558,12 @@ describe("memory-rater v1.5 — cross-cutting e2e", () => {
     );
 
     // The usefulness factor at Beta(1,1) is exactly 1.0; a memory with no
-    // ratings should score within numerical noise of similarity * recency *
-    // access (the original pre-v1.5 formula).
+    // ratings should score = similarity * recency * access * sourceQuality * usefulness.
+    // For source=manual: sourceQuality=1.5, recency=1.0 (no decay for manual),
+    // access=1.0, usefulness=1.0. So score = 0.5 * 1.5 = 0.75.
     const fresh = buildCandidate(0.5);
     const score = rerank([fresh], { limit: 1 })[0]!.similarity;
-    // recency at age = 0 is exactly 1; access_boost at count=0 is exactly 1;
-    // usefulness at (1,1) is exactly 1. So score === 0.5 to machine precision.
-    expect(score).toBeCloseTo(0.5, 10);
+    expect(score).toBeCloseTo(0.75, 10);
   });
 });