@desplega.ai/agent-swarm 1.98.1 → 1.99.1

package/README.md

@@ -127,6 +127,7 @@ Check [our templates](https://templates.agent-swarm.dev) for a quick start.
 - **Workflow engine with Human-in-the-Loop** — DAG-based automation with approval gates, retries, and structured I/O. [Workflows →](https://docs.agent-swarm.dev/docs/concepts/workflows)
 - **Scheduled & recurring tasks** — cron-based automation for standing work. [Scheduling →](https://docs.agent-swarm.dev/docs/concepts/scheduling)
 - **Durable script workflows** — launch background script runs, inspect their journals, and track them from the dashboard when a one-shot `script-run` is too small. [Guide →](https://docs.agent-swarm.dev/docs/guides/script-workflow-runs)
+- **E2B-backed eval harness** — run a scenario × harness-config matrix against real swarm stacks, capture transcripts/artifacts, and grade outcomes with deterministic checks plus LLM or agentic judges. [Guide →](https://docs.agent-swarm.dev/docs/guides/evals-harness)
 - **Harness & LLM agnostic** — run with Claude Code, Claude Bridge, OpenAI Codex, pi-mono (Anthropic, OpenRouter, or Amazon Bedrock), Devin, Claude Managed Agents, raw LLMs, or opencode. Tasks, schedules, and workflow agent-task nodes can use portable `modelTier` intent (`smol`, `regular`, `smart`, `ultra`) and resolve it per worker/provider at run time. [Harness config →](https://docs.agent-swarm.dev/docs/guides/harness-configuration) · [Add a new provider →](https://docs.agent-swarm.dev/docs/guides/harness-providers)
 - **Follow-up continuity across all harnesses** — child tasks inherit a bounded prior-task context preamble built from the task chain, so continuity survives restarts and works the same across every provider. [Task lifecycle →](https://docs.agent-swarm.dev/docs/concepts/task-lifecycle)
 - **Skills & MCP servers** — reusable procedural knowledge, bundled skill reference files, and per-agent MCP servers with scope cascade. [MCP tools →](https://docs.agent-swarm.dev/docs/reference/mcp-tools)

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.98.1",
+    "version": "1.99.1",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -4248,6 +4248,9 @@
                   },
                   "persistMemory": {
                     "type": "boolean"
+                  },
+                  "contextKey": {
+                    "type": "string"
                   }
                 },
                 "required": [
@@ -4291,6 +4294,11 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "intent": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Why you are searching. Required for agent recall-edge tracking; omit for UI browse/search calls."
+                  },
                   "limit": {
                     "type": "integer",
                     "minimum": 1,
@@ -4516,6 +4524,17 @@
             "required": true,
             "name": "id",
             "in": "path"
+          },
+          {
+            "schema": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Why you are retrieving this memory. Required for agent recall-edge tracking; omit for UI browse calls."
+            },
+            "required": false,
+            "description": "Why you are retrieving this memory. Required for agent recall-edge tracking; omit for UI browse calls.",
+            "name": "intent",
+            "in": "query"
           }
         ],
         "responses": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.98.1",
+  "version": "1.99.1",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -64,8 +64,8 @@
     "start:portless": "portless api.swarm bun --expose-gc src/http.ts",
     "inspector": "bunx @modelcontextprotocol/inspector --transport stdio bun src/stdio.ts",
     "inspector:http": "bunx @modelcontextprotocol/inspector --transport http https://api.swarm.localhost:1355/mcp",
-    "lint": "biome check src",
-    "lint:fix": "biome check --write src",
+    "lint": "biome check src evals",
+    "lint:fix": "biome check --write src evals",
     "format": "biome format --write src",
     "build:binary": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-x64 --outfile ./dist/agent-swarm",
     "build:binary:arm64": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-arm64 --outfile ./dist/agent-swarm",

package/src/be/boot-scrub-logs.ts

@@ -5,13 +5,24 @@
  *
  * Idempotent: already-scrubbed rows are no-ops (scrubSecrets is idempotent).
  * Uses seed_state to avoid re-scanning on subsequent boots.
+ *
+ * Restart-safe: progress is persisted as a cursor in seed_state after each
+ * batch, so a restart (e.g. K8s probe SIGKILL) resumes from the last
+ * committed batch instead of re-scanning from zero.
+ *
+ * Non-blocking: yields to the event loop between batches so /health and
+ * startup/liveness probes stay responsive.
  */
 
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { getDb } from "./db";
 
 const SCRUB_KEY = "boot-scrub-logs-v2";
-const BATCH_SIZE = 500;
+const CURSOR_KEY = "boot-scrub-logs-v2-cursor";
+const BATCH_SIZE = 200;
+
+/** Yield to the event loop so probes can respond. */
+const yieldTick = () => new Promise<void>((r) => setTimeout(r, 5));
 
 export async function runBootScrubLogs(): Promise<void> {
   const db = getDb();
@@ -24,46 +35,94 @@ export async function runBootScrubLogs(): Promise<void> {
 
   if (done) return;
 
-  // ESCAPE '!' makes ! the escape character so !_ matches a literal underscore
-  // instead of the LIKE single-char wildcard. Without this, '%npm_%' matches
-  // any row containing "npm" + any char (e.g. "npm install"), drowning real
-  // token rows when a LIMIT is applied.
-  const rows = db
-    .prepare<{ id: string; content: string }, []>(
-      `SELECT id, content FROM session_logs
-       WHERE content LIKE '%lin!_oauth!_%' ESCAPE '!'
-          OR content LIKE '%lin!_api!_%' ESCAPE '!'
-          OR content LIKE '%npm!_%' ESCAPE '!'
-          OR content LIKE '%ATATT%'`,
-    )
-    .all();
+  // Resume from last cursor if a previous run was interrupted
+  const savedCursor =
+    db
+      .prepare<{ seededHash: string }, [string, string]>(
+        "SELECT seededHash FROM seed_state WHERE kind = ? AND key = ?",
+      )
+      .get("maintenance", CURSOR_KEY)?.seededHash ?? "";
 
-  if (rows.length === 0) {
+  const lastProcessedId = savedCursor || "";
+
+  // Count total work remaining (for logging only)
+  const totalRemaining =
+    db
+      .prepare<{ count: number }, [string]>(
+        `SELECT COUNT(*) as count FROM session_logs
+         WHERE id > ?
+           AND (content LIKE '%lin!_oauth!_%' ESCAPE '!'
+             OR content LIKE '%lin!_api!_%' ESCAPE '!'
+             OR content LIKE '%npm!_%' ESCAPE '!'
+             OR content LIKE '%ATATT%')`,
+      )
+      .get(lastProcessedId)?.count ?? 0;
+
+  if (totalRemaining === 0) {
     markDone(db);
     return;
   }
 
-  console.log(`[boot-scrub-logs] starting: ${rows.length} candidate rows`);
+  console.log(
+    `[boot-scrub-logs] starting: ${totalRemaining} candidate rows remaining` +
+      (lastProcessedId ? ` (resuming from cursor ${lastProcessedId.slice(0, 8)}…)` : ""),
+  );
 
+  const selectBatch = db.prepare<{ id: string; content: string }, [string]>(
+    `SELECT id, content FROM session_logs
+     WHERE id > ?
+       AND (content LIKE '%lin!_oauth!_%' ESCAPE '!'
+         OR content LIKE '%lin!_api!_%' ESCAPE '!'
+         OR content LIKE '%npm!_%' ESCAPE '!'
+         OR content LIKE '%ATATT%')
+     ORDER BY id ASC
+     LIMIT ${BATCH_SIZE}`,
+  );
   const update = db.prepare("UPDATE session_logs SET content = ? WHERE id = ?");
+  const saveCursor = db.prepare(
+    `INSERT INTO seed_state (kind, key, seededHash, seededAt)
+     VALUES ('maintenance', '${CURSOR_KEY}', ?, datetime('now'))
+     ON CONFLICT (kind, key) DO UPDATE SET seededHash = ?, seededAt = datetime('now')`,
+  );
+
   let scrubbed = 0;
+  let scanned = 0;
+  let cursor = lastProcessedId;
+
+  // Paginated cursor loop — each iteration fetches the next BATCH_SIZE rows
+  // ordered by id, processes them in a transaction, saves the cursor, and
+  // yields to the event loop.
+  for (;;) {
+    const rows = selectBatch.all(cursor);
+    if (rows.length === 0) break;
+
+    const batchLastId = rows[rows.length - 1]!.id;
 
-  for (let i = 0; i < rows.length; i += BATCH_SIZE) {
-    const batch = rows.slice(i, i + BATCH_SIZE);
     const tx = db.transaction(() => {
-      for (const row of batch) {
+      for (const row of rows) {
         const cleaned = scrubSecrets(row.content);
         if (cleaned !== row.content) {
           update.run(cleaned, row.id);
           scrubbed++;
         }
       }
+      // Persist cursor inside the same transaction so it's atomic with the scrub
+      saveCursor.run(batchLastId, batchLastId);
     });
     tx();
+
+    scanned += rows.length;
+    cursor = batchLastId;
+
+    // Yield to the event loop between batches
+    await yieldTick();
   }
 
   markDone(db);
-  console.log(`[boot-scrub-logs] complete: scanned=${rows.length} scrubbed=${scrubbed}`);
+  // Clean up the cursor key now that we're fully done
+  db.run("DELETE FROM seed_state WHERE kind = 'maintenance' AND key = ?", [CURSOR_KEY]);
+
+  console.log(`[boot-scrub-logs] complete: scanned=${scanned} scrubbed=${scrubbed}`);
 }
 
 function markDone(db: ReturnType<typeof getDb>) {

package/src/be/memory/link-resolver.ts

@@ -0,0 +1,226 @@
+/**
+ * Deterministic link resolver for memory content.
+ *
+ * Scans memory content for recognizable patterns (wikilinks, agent-fs paths,
+ * PR references, agent-UI URLs) and resolves them to typed `memory_link` rows.
+ * Phase 1: capture layer only — no traversal tools, no reranker integration.
+ */
+import { getDb } from "@/be/db";
+
+export type LinkType =
+  | "wikilink"
+  | "sequel"
+  | "agent-fs-file"
+  | "agent-ui"
+  | "pr"
+  | "external-source";
+export type TargetKind = "memory" | "agent-fs-file" | "agent-ui" | "pr" | "external-source";
+
+export interface ResolvedLink {
+  linkType: LinkType;
+  targetKind: TargetKind;
+  targetId: string;
+  strength: number;
+  resolver: string;
+  sourceText: string;
+  metadata?: Record<string, unknown>;
+}
+
+interface MatcherResult {
+  linkType: LinkType;
+  targetKind: TargetKind;
+  targetId: string;
+  sourceText: string;
+  resolver: string;
+  metadata?: Record<string, unknown>;
+}
+
+type Matcher = (content: string) => MatcherResult[];
+
+const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+const PR_HASH_RE = /(?:^|[\s(])#(\d{1,5})(?=[\s,.)!?]|$)/gm;
+const PR_PREFIX_RE = /\bPR\s*#(\d{1,5})\b/gi;
+const GITHUB_PR_URL_RE = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
+const AGENT_FS_PATH_RE =
+  /(?:agent-fs|live\.agent-fs\.dev)\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)/g;
+const AGENT_UI_PAGE_RE = /(?:app\.[^/]+|localhost:\d+)\/pages\/([a-f0-9-]+)/g;
+const AGENT_UI_TASK_RE = /(?:app\.[^/]+|localhost:\d+)\/tasks\/([a-f0-9-]+)/g;
+
+const wikilinkMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(WIKILINK_RE)) {
+    const name = match[1]!.trim();
+    if (!name) continue;
+    results.push({
+      linkType: "wikilink",
+      targetKind: "memory",
+      targetId: name,
+      sourceText: match[0],
+      resolver: "wikilink",
+    });
+  }
+  return results;
+};
+
+const prMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  const seen = new Set<string>();
+
+  for (const match of content.matchAll(GITHUB_PR_URL_RE)) {
+    const id = `github:${match[1]}/${match[2]}#${match[3]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0],
+      resolver: "pr-url",
+      metadata: { owner: match[1], repo: match[2], number: Number(match[3]) },
+    });
+  }
+
+  for (const match of content.matchAll(PR_PREFIX_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0].trim(),
+      resolver: "pr-prefix",
+      metadata: { number: Number(match[1]) },
+    });
+  }
+
+  for (const match of content.matchAll(PR_HASH_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: `#${match[1]}`,
+      resolver: "pr-hash",
+      metadata: { number: Number(match[1]) },
+    });
+  }
+
+  return results;
+};
+
+const agentFsMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(AGENT_FS_PATH_RE)) {
+    const orgId = match[1]!;
+    const driveId = match[2]!;
+    const path = match[3]!;
+    results.push({
+      linkType: "agent-fs-file",
+      targetKind: "agent-fs-file",
+      targetId: `${orgId}/${driveId}/${path}`,
+      sourceText: match[0],
+      resolver: "agent-fs-path",
+      metadata: { orgId, driveId, path },
+    });
+  }
+  return results;
+};
+
+const agentUiMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(AGENT_UI_PAGE_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `page:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-page",
+    });
+  }
+  for (const match of content.matchAll(AGENT_UI_TASK_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `task:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-task",
+    });
+  }
+  return results;
+};
+
+const MATCHERS: Matcher[] = [wikilinkMatcher, prMatcher, agentFsMatcher, agentUiMatcher];
+
+export function resolveLinks(content: string): ResolvedLink[] {
+  const results: ResolvedLink[] = [];
+  for (const matcher of MATCHERS) {
+    for (const link of matcher(content)) {
+      results.push({ ...link, strength: 1.0 });
+    }
+  }
+  return results;
+}
+
+export function resolveWikilinksToMemoryIds(
+  agentId: string,
+  links: ResolvedLink[],
+): ResolvedLink[] {
+  const db = getDb();
+  const findByName = db.prepare<{ id: string }, [string, string]>(
+    "SELECT id FROM agent_memory WHERE name = ? AND (agentId = ? OR scope = 'swarm') LIMIT 1",
+  );
+
+  return links.map((link) => {
+    if (link.linkType !== "wikilink") return link;
+    const row = findByName.get(link.targetId, agentId);
+    if (row) {
+      return { ...link, targetId: row.id };
+    }
+    return link;
+  });
+}
+
+export function storeLinks(memoryId: string, agentId: string, content: string): void {
+  const links = resolveLinks(content);
+  if (links.length === 0) return;
+
+  const resolved = resolveWikilinksToMemoryIds(agentId, links);
+  const db = getDb();
+  const now = new Date().toISOString();
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO memory_link
+       (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+
+  db.transaction(() => {
+    for (const link of resolved) {
+      insert.run(
+        crypto.randomUUID(),
+        memoryId,
+        link.linkType,
+        link.targetKind,
+        link.targetId,
+        link.strength,
+        link.resolver,
+        link.sourceText,
+        link.metadata ? JSON.stringify(link.metadata) : null,
+        now,
+        now,
+      );
+    }
+  })();
+}
+
+export function storeSequelLink(fromMemoryId: string, toMemoryId: string): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare(
+    `INSERT OR IGNORE INTO memory_link
+       (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+     VALUES (?, ?, 'sequel', 'memory', ?, 1.0, 'sequel-auto', NULL, NULL, ?, ?)`,
+  ).run(crypto.randomUUID(), fromMemoryId, toMemoryId, now, now);
+}

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

@@ -259,10 +259,11 @@ export class SqliteMemoryStore implements MemoryStore {
           string | null,
           number,
           string | null,
+          string | null,
         ]
       >(
-        `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt, expiresAt, accessCount, embeddingModel)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+        `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt, expiresAt, accessCount, embeddingModel, contextKey)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
       )
       .get(
         id,
@@ -282,6 +283,7 @@ export class SqliteMemoryStore implements MemoryStore {
         expiresAt,
         0,
         null,
+        input.contextKey ?? null,
       );
 
     if (!row) throw new Error("Failed to create memory");

package/src/be/memory/raters/retrieval.ts

@@ -24,24 +24,32 @@ export type RetrievalRecord = {
   similarity: number;
 };
 
+export type RetrievalExtras = {
+  intent?: string;
+  contextKey?: string;
+  eventType?: "search" | "get";
+};
+
 export function recordRetrievals(
   taskId: string | undefined,
   agentId: string,
   results: RetrievalRecord[],
   sessionId?: string,
+  extras?: RetrievalExtras,
 ): void {
   if (!taskId || results.length === 0) return;
 
   const db = getDb();
   const insert = db.prepare(
     `INSERT INTO memory_retrieval
-       (id, taskId, agentId, sessionId, memoryId, similarity, retrievedAt)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+       (id, taskId, agentId, sessionId, memoryId, similarity, retrievedAt, contextKey, intent, eventType)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   const now = new Date().toISOString();
+  const contextKey = extras?.contextKey ?? null;
+  const intent = extras?.intent ?? null;
+  const eventType = extras?.eventType ?? "search";
 
-  // Single transaction: even on a 100-row paginated search this is one
-  // commit, not N. No-op when results is empty.
   db.transaction(() => {
     for (const r of results) {
       insert.run(
@@ -52,6 +60,9 @@ export function recordRetrievals(
         r.memoryId,
         r.similarity,
         now,
+        contextKey,
+        intent,
+        eventType,
       );
     }
   })();

package/src/be/memory/raters/store.ts

@@ -31,6 +31,7 @@ export type ApplyRatingResult = {
 
 export type ApplyRatingContext = {
   taskId?: string;
+  contextKey?: string;
 };
 
 export class ExplicitSelfDuplicateError extends Error {
@@ -100,8 +101,8 @@ export function applyRating(
   );
   const insertRating = db.prepare(
     `INSERT INTO memory_rating
-       (id, memoryId, taskId, source, signal, weight, reasoning, createdAt)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+       (id, memoryId, taskId, source, signal, weight, reasoning, createdAt, contextKey)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   // Step-6 §3 — UPSERT the edge with the SAME deltas as the memory row.
   // The `- 1.0` corrections in DO UPDATE undo the default-prior offset that
@@ -141,6 +142,7 @@ export function applyRating(
           event.weight,
           event.reasoning ?? null,
           new Date().toISOString(),
+          ctx.contextKey ?? null,
         );
       } catch (err) {
         // Partial unique index on (taskId, memoryId) WHERE source='explicit-self'

package/src/be/memory/types.ts

@@ -52,6 +52,7 @@ export interface MemoryInput {
   chunkIndex?: number;
   totalChunks?: number;
   tags?: string[];
+  contextKey?: string | null;
 }
 
 export interface MemoryCandidate extends AgentMemory {

package/src/be/migrations/096_memory_graph_phase1.sql

@@ -0,0 +1,50 @@
+-- Phase 1 of memory-graph recall-edges: contextKey threading, intent capture,
+-- memory-get retrieval events, and deterministic typed links.
+
+-- 1. Add contextKey to agent_memory (born-under context)
+ALTER TABLE agent_memory ADD COLUMN contextKey TEXT;
+CREATE INDEX idx_agent_memory_context_key ON agent_memory(contextKey);
+
+-- 2. Extend memory_retrieval with contextKey, intent, and eventType
+ALTER TABLE memory_retrieval ADD COLUMN contextKey TEXT;
+ALTER TABLE memory_retrieval ADD COLUMN intent TEXT;
+ALTER TABLE memory_retrieval ADD COLUMN eventType TEXT NOT NULL DEFAULT 'search'
+    CHECK (eventType IN ('search', 'get'));
+CREATE INDEX idx_memret_context_key ON memory_retrieval(contextKey);
+CREATE INDEX idx_memret_event_type ON memory_retrieval(eventType);
+
+-- 3. Add contextKey to memory_rating
+ALTER TABLE memory_rating ADD COLUMN contextKey TEXT;
+CREATE INDEX idx_memrat_context_key ON memory_rating(contextKey);
+
+-- 4. New table: memory_link — deterministic typed links between memories
+--    and external entities (agent-fs files, PRs, agent-UI pages, etc.)
+CREATE TABLE IF NOT EXISTS memory_link (
+    id             TEXT PRIMARY KEY,
+    from_memory_id TEXT NOT NULL,
+    linkType       TEXT NOT NULL CHECK (
+        linkType IN (
+            'wikilink',
+            'sequel',
+            'agent-fs-file',
+            'agent-ui',
+            'pr',
+            'external-source'
+        )
+    ),
+    targetKind     TEXT NOT NULL CHECK (
+        targetKind IN ('memory', 'agent-fs-file', 'agent-ui', 'pr', 'external-source')
+    ),
+    targetId       TEXT NOT NULL,
+    strength       REAL NOT NULL DEFAULT 1.0,
+    resolver       TEXT NOT NULL,
+    sourceText     TEXT,
+    metadata       TEXT,
+    createdAt      TEXT NOT NULL,
+    updatedAt      TEXT NOT NULL,
+    UNIQUE (from_memory_id, linkType, targetKind, targetId, sourceText),
+    FOREIGN KEY (from_memory_id) REFERENCES agent_memory(id) ON DELETE CASCADE
+);
+CREATE INDEX idx_memlink_from ON memory_link(from_memory_id);
+CREATE INDEX idx_memlink_target ON memory_link(targetKind, targetId);
+CREATE INDEX idx_memlink_type ON memory_link(linkType);

package/src/be/scripts/typecheck.ts

@@ -51,8 +51,8 @@ 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_search(args: { query: string; intent: string; scope?: "all" | "agent" | "swarm"; limit?: number; source?: string }): Promise<unknown>;
+  memory_get(args: { memoryId: string; intent: string }): Promise<unknown>;
   memory_rate(args: { id: string; useful: boolean; note?: string }): Promise<unknown>;
   // --- tasks ---
   task_list(args?: Record<string, unknown>): Promise<unknown>;
@@ -176,6 +176,7 @@ export interface SwarmSdk {
   // --- skills ---
   skill_list(args?: { scope?: string; scopeId?: string; includeBuiltin?: boolean }): Promise<unknown>;
   skill_get(args: { id: string }): Promise<unknown>;
+  skill_getFile(args: { skillId: string; path: 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>;