@desplega.ai/agent-swarm 1.92.1 → 1.93.0

package/src/be/memory/providers/sqlite-store.ts

@@ -1,7 +1,12 @@
 import { getDb, isSqliteVecAvailable } from "@/be/db";
 import { cosineSimilarity, deserializeEmbedding, serializeEmbedding } from "@/be/embedding";
 import type { AgentMemory, AgentMemoryScope, AgentMemorySource } from "@/types";
-import { EMBEDDING_DIMENSIONS, TTL_DEFAULTS } from "../constants";
+import {
+  EMBEDDING_DIMENSIONS,
+  MIN_SIMILARITY,
+  PROTECTED_SOURCES,
+  TTL_DEFAULTS,
+} from "../constants";
 import type {
   MemoryCandidate,
   MemoryHealth,
@@ -400,6 +405,7 @@ export class SqliteMemoryStore implements MemoryStore {
     const candidates: MemoryCandidate[] = [];
     for (const row of rows) {
       const similarity = 1 - row.distance;
+      if (similarity < MIN_SIMILARITY) continue;
       candidates.push(rowToCandidate(row, similarity));
     }
 
@@ -446,6 +452,7 @@ export class SqliteMemoryStore implements MemoryStore {
       const emb = deserializeEmbedding(row.embedding);
       if (emb.length !== queryEmbedding.length) continue;
       const similarity = cosineSimilarity(queryEmbedding, emb);
+      if (similarity < MIN_SIMILARITY) continue;
       candidates.push(rowToCandidate(row, similarity));
     }
 
@@ -481,29 +488,19 @@ export class SqliteMemoryStore implements MemoryStore {
     }
   }
 
-  list(agentId: string, options: MemoryListOptions = {}): AgentMemory[] {
-    const { scope = "all", limit = 20, offset = 0, isLead = false, source } = options;
-    const db = getDb();
-
+  private buildListWhereClause(
+    agentId: string,
+    options: MemoryListOptions,
+  ): { whereClause: string; params: (Buffer | string | number | null)[] } {
+    const { scope = "all", isLead = false, ownerAgentId, source, sourcePath } = options;
     const conditions: string[] = [];
-    const params: (string | number)[] = [];
+    const params: (Buffer | string | number | null)[] = [];
 
-    if (!isLead) {
-      if (scope === "agent") {
-        conditions.push("agentId = ? AND scope = 'agent'");
-        params.push(agentId);
-      } else if (scope === "swarm") {
-        conditions.push("scope = 'swarm'");
-      } else {
-        conditions.push("(agentId = ? OR scope = 'swarm')");
-        params.push(agentId);
-      }
-    } else {
-      if (scope === "agent") {
-        conditions.push("scope = 'agent'");
-      } else if (scope === "swarm") {
-        conditions.push("scope = 'swarm'");
-      }
+    this.addScopeConditions(conditions, params, agentId, scope, isLead);
+
+    if (ownerAgentId) {
+      conditions.push("agentId = ?");
+      params.push(ownerAgentId);
     }
 
     if (source) {
@@ -511,18 +508,70 @@ export class SqliteMemoryStore implements MemoryStore {
       params.push(source);
     }
 
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    params.push(limit, offset);
+    const sourcePathNeedle = sourcePath?.trim().toLowerCase();
+    if (sourcePathNeedle) {
+      conditions.push("instr(lower(coalesce(sourcePath, '')), ?) > 0");
+      params.push(sourcePathNeedle);
+    }
+
+    return {
+      whereClause: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+      params,
+    };
+  }
+
+  list(agentId: string, options: MemoryListOptions = {}): AgentMemory[] {
+    const { limit = 20, offset = 0 } = options;
+    const db = getDb();
+    const { whereClause, params } = this.buildListWhereClause(agentId, options);
+    const queryParams = [...params, limit, offset];
 
     const rows = db
-      .prepare<AgentMemoryRow, (string | number)[]>(
+      .prepare<AgentMemoryRow, (Buffer | string | number | null)[]>(
         `SELECT * FROM agent_memory ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
       )
-      .all(...params);
+      .all(...queryParams);
 
     return rows.map(rowToAgentMemory);
   }
 
+  count(agentId: string, options: MemoryListOptions = {}): number {
+    const db = getDb();
+    const { whereClause, params } = this.buildListWhereClause(agentId, options);
+    const row = db
+      .prepare<{ count: number }, (Buffer | string | number | null)[]>(
+        `SELECT COUNT(*) AS count FROM agent_memory ${whereClause}`,
+      )
+      .get(...params);
+
+    return row?.count ?? 0;
+  }
+
+  isSourceProtected(source: AgentMemorySource): boolean {
+    return PROTECTED_SOURCES.has(source);
+  }
+
+  listForCuration(
+    agentId?: string,
+  ): { id: string; source: string; name: string; createdAt: string }[] {
+    const db = getDb();
+    const protectedList = [...PROTECTED_SOURCES].map((s) => `'${s}'`).join(",");
+    if (agentId) {
+      return db
+        .prepare<{ id: string; source: string; name: string; createdAt: string }, [string]>(
+          `SELECT id, source, name, createdAt FROM agent_memory
+           WHERE agentId = ? AND source NOT IN (${protectedList})`,
+        )
+        .all(agentId);
+    }
+    return db
+      .prepare<{ id: string; source: string; name: string; createdAt: string }, []>(
+        `SELECT id, source, name, createdAt FROM agent_memory
+         WHERE source NOT IN (${protectedList})`,
+      )
+      .all();
+  }
+
   listForReembedding(options?: { agentId?: string }): { id: string; content: string }[] {
     const db = getDb();
     if (options?.agentId) {

package/src/be/memory/raters/llm-client.ts

@@ -75,6 +75,13 @@ AGENT RESPONSE / SUMMARY:
 
 Score 0..1.`;
 
+const PLACEHOLDER_PREFIX = "$";
+const QUERY_PLACEHOLDER = `${PLACEHOLDER_PREFIX}{query}`;
+const MEMORY_ID_PLACEHOLDER = `${PLACEHOLDER_PREFIX}{memoryId}`;
+const MEMORY_NAME_PLACEHOLDER = `${PLACEHOLDER_PREFIX}{memoryName}`;
+const MEMORY_CONTENT_PLACEHOLDER = `${PLACEHOLDER_PREFIX}{memoryContent}`;
+const RESPONSE_PLACEHOLDER = `${PLACEHOLDER_PREFIX}{response}`;
+
 /**
  * `claude -p --output-format json` returns a JSON envelope of the shape
  * `{ result: string, ... }`. We parse the envelope, then JSON-parse the
@@ -83,11 +90,11 @@ Score 0..1.`;
 type ClaudeCliEnvelope = { result?: unknown };
 
 function buildPrompt(input: LlmRaterInput): string {
-  return PROMPT_TEMPLATE.replace("${query}", input.query)
-    .replace("${memoryId}", input.memory.id)
-    .replace("${memoryName}", input.memory.name)
-    .replace("${memoryContent}", input.memory.content)
-    .replace("${response}", input.response);
+  return PROMPT_TEMPLATE.replace(QUERY_PLACEHOLDER, input.query)
+    .replace(MEMORY_ID_PLACEHOLDER, input.memory.id)
+    .replace(MEMORY_NAME_PLACEHOLDER, input.memory.name)
+    .replace(MEMORY_CONTENT_PLACEHOLDER, input.memory.content)
+    .replace(RESPONSE_PLACEHOLDER, input.response);
 }
 
 function parseScoreAndReasoning(raw: unknown): LlmRaterResult | null {

package/src/be/memory/reranker.ts

@@ -1,7 +1,10 @@
+import type { AgentMemorySource } from "@/types";
 import {
   ACCESS_BOOST_MAX_MULTIPLIER,
   ACCESS_BOOST_RECENCY_WINDOW_HOURS,
+  RECENCY_DECAY_HALF_LIFE,
   RECENCY_DECAY_HALF_LIFE_DAYS,
+  SOURCE_QUALITY_MULTIPLIER,
 } from "./constants";
 import type { MemoryCandidate, RerankOptions } from "./types";
 
@@ -9,13 +12,16 @@ const MS_PER_DAY = 1000 * 60 * 60 * 24;
 const MS_PER_HOUR = 1000 * 60 * 60;
 
 /**
- * Exponential decay based on age. A memory at exactly HALF_LIFE_DAYS old
- * gets multiplied by 0.5. Fresh memories get ~1.0.
+ * Exponential decay based on age and memory source.
+ * Source-aware: manual memories have no decay (Infinity half-life),
+ * file_index = 180d, task_completion = 14d, session_summary = 7d.
  */
-export function recencyDecay(createdAt: string, now: Date): number {
+export function recencyDecay(createdAt: string, now: Date, source?: AgentMemorySource): number {
+  const halfLife = source ? RECENCY_DECAY_HALF_LIFE[source] : RECENCY_DECAY_HALF_LIFE_DAYS;
+  if (!Number.isFinite(halfLife)) return 1.0;
   const ageDays = (now.getTime() - new Date(createdAt).getTime()) / MS_PER_DAY;
   if (ageDays <= 0) return 1.0;
-  return 2 ** (-ageDays / RECENCY_DECAY_HALF_LIFE_DAYS);
+  return 2 ** (-ageDays / halfLife);
 }
 
 /**
@@ -31,6 +37,14 @@ export function accessBoost(accessedAt: string, accessCount: number, now: Date):
   return boost;
 }
 
+/**
+ * Source-quality multiplier. Manual memories get a 1.5× boost,
+ * session summaries get 0.5×. Unknown sources default to 1.0.
+ */
+export function sourceQuality(source: AgentMemorySource): number {
+  return SOURCE_QUALITY_MULTIPLIER[source] ?? 1.0;
+}
+
 /**
  * Beta-Binomial usefulness factor for reranking.
  *
@@ -56,33 +70,37 @@ export function usefulness(alpha: number, beta: number): number {
 }
 
 /**
- * Final score combining similarity, recency decay, access boost, and
- * Beta-Binomial usefulness. With default Beta(1,1) and default
- * MEMORY_DEMOTION_FLOOR=1.0, the usefulness factor is exactly 1.0 and this
- * computation matches the pre-rater behaviour byte-for-byte.
- *
- * v2: optional edge-aware boost — see thoughts/taras/plans/2026-05-05-memory-rater-v1.5/root.md
+ * Final score combining similarity, recency decay, access boost,
+ * source quality, and Beta-Binomial usefulness.
  */
 export function computeScore(candidate: MemoryCandidate, now: Date): number {
   return (
     candidate.similarity *
-    recencyDecay(candidate.createdAt, now) *
+    recencyDecay(candidate.createdAt, now, candidate.source) *
     accessBoost(candidate.accessedAt, candidate.accessCount, now) *
+    sourceQuality(candidate.source) *
     usefulness(candidate.alpha, candidate.beta)
   );
 }
 
 /**
- * Rerank candidates by combining similarity with recency and access signals.
- * Returns the top `limit` candidates sorted by final score.
+ * Rerank candidates by combining similarity with recency, source quality,
+ * and access signals. Returns the top `limit` candidates sorted by composite
+ * score. Preserves raw similarity in `rawSimilarity` and sets `compositeScore`.
  */
 export function rerank(candidates: MemoryCandidate[], options: RerankOptions): MemoryCandidate[] {
   const { limit, now = new Date() } = options;
 
-  const scored = candidates.map((candidate) => ({
-    ...candidate,
-    similarity: computeScore(candidate, now),
-  }));
+  const scored = candidates.map((candidate) => {
+    const rawSimilarity = candidate.similarity;
+    const compositeScore = computeScore(candidate, now);
+    return {
+      ...candidate,
+      rawSimilarity,
+      compositeScore,
+      similarity: compositeScore,
+    };
+  });
 
   scored.sort((a, b) => b.similarity - a.similarity);
   return scored.slice(0, limit);

package/src/be/memory/types.ts

@@ -22,6 +22,11 @@ export interface MemoryStore {
   peek(id: string): AgentMemory | null;
   search(embedding: Float32Array, agentId: string, options: MemorySearchOptions): MemoryCandidate[];
   list(agentId: string, options: MemoryListOptions): AgentMemory[];
+  count(agentId: string, options: MemoryListOptions): number;
+  isSourceProtected(source: AgentMemorySource): boolean;
+  listForCuration(
+    agentId?: string,
+  ): { id: string; source: string; name: string; createdAt: string }[];
   listForReembedding(options?: { agentId?: string }): { id: string; content: string }[];
   delete(id: string): boolean;
   deleteBySourcePath(sourcePath: string, agentId: string): number;
@@ -51,6 +56,10 @@ export interface MemoryInput {
 
 export interface MemoryCandidate extends AgentMemory {
   similarity: number;
+  /** Raw cosine similarity before reranking (preserved for diagnostics). */
+  rawSimilarity?: number;
+  /** Final composite score after reranking (recency × source × usefulness × access). */
+  compositeScore?: number;
   accessCount: number;
   expiresAt: string | null;
   embeddingModel: string | null;
@@ -72,7 +81,9 @@ export interface MemoryListOptions {
   limit?: number;
   offset?: number;
   isLead?: boolean;
+  ownerAgentId?: string;
   source?: AgentMemorySource;
+  sourcePath?: string;
 }
 
 export interface MemoryStats {

package/src/be/migrations/088_script_runs_list_indexes.sql

@@ -0,0 +1,10 @@
+-- Keep script run list pages fast as historical rows accumulate.
+
+CREATE INDEX IF NOT EXISTS idx_script_runs_startedAt
+  ON script_runs(startedAt DESC);
+
+CREATE INDEX IF NOT EXISTS idx_script_runs_status_startedAt
+  ON script_runs(status, startedAt DESC);
+
+CREATE INDEX IF NOT EXISTS idx_script_runs_agentId_startedAt
+  ON script_runs(agentId, startedAt DESC);

package/src/be/migrations/089_harness_variant.sql

@@ -0,0 +1,2 @@
+ALTER TABLE agent_tasks ADD COLUMN harnessVariant TEXT;
+ALTER TABLE agent_tasks ADD COLUMN harnessVariantMeta TEXT;