@desplega.ai/agent-swarm 1.74.4 → 1.76.0

package/src/tests/stop-hook-task-resolution.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Stop-hook task-context resolution.
+ *
+ * Regression for the silent-drop bug PR #444's gate trace surfaced: every Stop
+ * hook logged `hasTaskId: false` because TASK_FILE on disk had been cleaned up
+ * mid-session, so `Bun.file(taskFile).text()` threw and the catch swallowed it.
+ * Fix: prefer the AGENT_SWARM_TASK_ID env var (set by `claude-adapter.ts`) and
+ * only fall back to the file. See `resolveStopHookTaskContext` in hook.ts.
+ */
+import { describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { resolveStopHookTaskContext } from "../hooks/hook";
+
+describe("resolveStopHookTaskContext", () => {
+  test("prefers AGENT_SWARM_TASK_ID env var when TASK_FILE is missing on disk", async () => {
+    const missingPath = `/tmp/stop-hook-missing-${Date.now()}.json`;
+    // Sanity: file must not exist.
+    try {
+      await unlink(missingPath);
+    } catch {}
+
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      AGENT_SWARM_TASK_ID: "task-from-env-123",
+      TASK_FILE: missingPath,
+    });
+
+    expect(taskId).toBe("task-from-env-123");
+    // taskContext stays empty because the file (which carries the human task
+    // text) wasn't readable. That's fine — the LLM rater only needs taskId.
+    expect(taskContext).toBe("");
+  });
+
+  test("env var alone (no TASK_FILE) still populates taskId", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      AGENT_SWARM_TASK_ID: "task-env-only",
+    });
+    expect(taskId).toBe("task-env-only");
+    expect(taskContext).toBe("");
+  });
+
+  test("falls back to TASK_FILE.id when env var unset", async () => {
+    const path = `/tmp/stop-hook-file-${Date.now()}.json`;
+    await Bun.write(path, JSON.stringify({ id: "task-from-file-456", task: "do the thing" }));
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-from-file-456");
+      expect(taskContext).toBe("Task: do the thing");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+
+  test("env var wins over TASK_FILE.id but file still seeds taskContext", async () => {
+    const path = `/tmp/stop-hook-both-${Date.now()}.json`;
+    await Bun.write(path, JSON.stringify({ id: "task-from-file", task: "human task text" }));
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        AGENT_SWARM_TASK_ID: "task-from-env",
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-from-env");
+      expect(taskContext).toBe("Task: human task text");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+
+  test("missing file with no env var → both undefined/empty (no throw)", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      TASK_FILE: `/tmp/stop-hook-nope-${Date.now()}.json`,
+    });
+    expect(taskId).toBeUndefined();
+    expect(taskContext).toBe("");
+  });
+
+  test("no env at all → both undefined/empty", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({});
+    expect(taskId).toBeUndefined();
+    expect(taskContext).toBe("");
+  });
+
+  test("malformed TASK_FILE JSON does not throw, env var still wins", async () => {
+    const path = `/tmp/stop-hook-bad-${Date.now()}.json`;
+    await Bun.write(path, "not json {");
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        AGENT_SWARM_TASK_ID: "task-env-survives",
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-env-survives");
+      expect(taskContext).toBe("");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+});

package/src/tests/template-recommendations.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Phase 3 — unit tests for `ui/src/lib/template-recommendations.ts`.
+ *
+ * Lives in `src/tests/` (not under `ui/`) because `ui/` has no test runner
+ * configured. The recommendation lib is pure logic with only a `StatusResponse`
+ * type import, so the cross-tree relative import works without aliases.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { StatusResponse } from "../../ui/src/api/types.ts";
+import {
+  type DetectedIntegration,
+  detectedFromStatus,
+  recommendTemplates,
+  topRecommendation,
+} from "../../ui/src/lib/template-recommendations.ts";
+
+function makeStatus(overrides: {
+  slack?: "unverified" | "configured" | "verified";
+  github?: "unverified" | "configured" | "verified";
+  linear?: "unverified" | "configured" | "verified";
+  jira?: "unverified" | "configured" | "verified";
+}): StatusResponse {
+  return {
+    identity: {
+      name: "Swarm",
+      logo_url: null,
+      brand_color: null,
+      is_cloud: false,
+      marketing_url: null,
+      hide_cloud_promo: false,
+    },
+    setup: [
+      { id: "harness", label: "Harness", state: "unverified" },
+      { id: "slack", label: "Slack", state: overrides.slack ?? "unverified" },
+      { id: "github", label: "GitHub", state: overrides.github ?? "unverified" },
+      { id: "linear", label: "Linear", state: overrides.linear ?? "unverified" },
+      { id: "jira", label: "Jira", state: overrides.jira ?? "unverified" },
+      { id: "workers", label: "Workers", state: "unverified" },
+      { id: "first_task", label: "First task", state: "unverified" },
+    ],
+    activity: { agents_online: 0, leads_online: 0, recent_tasks_count: 0 },
+    agent_fs: { configured: false, base_url: null },
+    health: "broken",
+  };
+}
+
+describe("recommendTemplates — priority rules", () => {
+  test("slack + github → pr-triage", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack", "github"]));
+    expect(recs[0]?.templateId).toBe("pr-triage");
+  });
+
+  test("linear + github → issue-to-pr", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["linear", "github"]));
+    expect(recs[0]?.templateId).toBe("issue-to-pr");
+  });
+
+  test("jira → bug-intake", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["jira"]));
+    expect(recs[0]?.templateId).toBe("bug-intake");
+  });
+
+  test("empty set → hello-world fallback", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>());
+    expect(recs).toHaveLength(1);
+    expect(recs[0]?.templateId).toBe("hello-world");
+    expect(recs[0]?.reason).toMatch(/hello world/i);
+  });
+
+  test("slack alone falls through to hello-world (no PR-triage promo without GitHub)", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("github alone falls through to hello-world", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["github"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("linear alone falls through to hello-world", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["linear"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("priority — slack+github+linear matches pr-triage first, also matches issue-to-pr", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack", "github", "linear"]));
+    // pr-triage comes first because slack+github rule is listed before linear+github.
+    expect(recs[0]?.templateId).toBe("pr-triage");
+    expect(recs.map((r) => r.templateId)).toContain("issue-to-pr");
+  });
+
+  test("all four detected — all three rule-based recs returned, no fallback", () => {
+    const recs = recommendTemplates(
+      new Set<DetectedIntegration>(["slack", "github", "linear", "jira"]),
+    );
+    const ids = recs.map((r) => r.templateId);
+    expect(ids).toEqual(["pr-triage", "issue-to-pr", "bug-intake"]);
+    expect(ids).not.toContain("hello-world");
+  });
+});
+
+describe("detectedFromStatus", () => {
+  test("verified milestones count as detected", () => {
+    const status = makeStatus({ slack: "verified", github: "verified" });
+    const detected = detectedFromStatus(status);
+    expect(detected.has("slack")).toBe(true);
+    expect(detected.has("github")).toBe(true);
+  });
+
+  test("configured milestones count as detected (live-call not required)", () => {
+    const status = makeStatus({ slack: "configured", jira: "configured" });
+    const detected = detectedFromStatus(status);
+    expect(detected.has("slack")).toBe(true);
+    expect(detected.has("jira")).toBe(true);
+  });
+
+  test("unverified milestones do NOT count as detected", () => {
+    const status = makeStatus({ slack: "unverified", github: "unverified" });
+    const detected = detectedFromStatus(status);
+    expect(detected.size).toBe(0);
+  });
+
+  test("non-integration milestones (harness, workers, first_task) are excluded", () => {
+    const status = makeStatus({});
+    // All four integration milestones are unverified by default; harness etc.
+    // are also unverified — none should leak into the detected set.
+    const detected = detectedFromStatus(status);
+    expect(detected.size).toBe(0);
+  });
+});
+
+describe("topRecommendation — end-to-end from a /status payload", () => {
+  test("slack+github verified → pr-triage", () => {
+    const status = makeStatus({ slack: "verified", github: "verified" });
+    expect(topRecommendation(status).templateId).toBe("pr-triage");
+  });
+
+  test("linear configured + github verified → issue-to-pr", () => {
+    const status = makeStatus({ linear: "configured", github: "verified" });
+    expect(topRecommendation(status).templateId).toBe("issue-to-pr");
+  });
+
+  test("nothing connected → hello-world", () => {
+    const status = makeStatus({});
+    expect(topRecommendation(status).templateId).toBe("hello-world");
+  });
+});

package/src/tests/tool-annotations.test.ts

@@ -179,8 +179,8 @@ describe("Tool Annotations & Classification", () => {
     expect(overlap).toEqual([]);
   });
 
-  test("CORE_TOOLS contains exactly 14 tools", () => {
-    expect(CORE_TOOLS.size).toBe(14);
+  test("CORE_TOOLS contains exactly 15 tools", () => {
+    expect(CORE_TOOLS.size).toBe(15);
   });
 
   test("ALL_TOOLS equals CORE_TOOLS union DEFERRED_TOOLS", () => {

package/src/tests/use-dismissible-card.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Phase 4 — pure-logic tests for `ui/src/hooks/use-dismissible-card.ts`.
+ *
+ * Lives in `src/tests/` (not under `ui/`) because:
+ *   - `ui/` has no test runner configured (no vitest/jest).
+ *   - The repo-root `bun test` already wires preload + DB fixtures.
+ *   - We test the pure `deriveStorageKey()` helper plus localStorage-shape
+ *     semantics by stubbing `globalThis.localStorage` — no React renderer.
+ *
+ * Hook semantics covered:
+ *   - Namespace key derivation (format + uniqueness across apiUrls).
+ *   - Dismiss / restore round-trip via the underlying localStorage shape.
+ *   - Namespace isolation between two distinct apiUrls.
+ *   - Graceful failure when `localStorage` throws.
+ *
+ * Cross-tab `storage` event handling lives in the React layer and is
+ * covered by the qa-use sessions in Success Criteria; pure-logic tests
+ * cannot exercise the `addEventListener("storage", …)` wiring meaningfully.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+// Import the pure helper directly — the parent `use-dismissible-card.ts`
+// pulls in React + the `@/lib/config` alias chain via `useConfig`, which
+// the bun-test runner can't resolve outside Vite.
+import { deriveStorageKey } from "../../ui/src/hooks/use-dismissible-card-key.ts";
+
+// Minimal in-memory localStorage shim for the round-trip / failure tests.
+class MemoryStorage {
+  private store = new Map<string, string>();
+  private throwOnSet = false;
+
+  setThrowOnSet(value: boolean) {
+    this.throwOnSet = value;
+  }
+  getItem(key: string): string | null {
+    return this.store.has(key) ? (this.store.get(key) as string) : null;
+  }
+  setItem(key: string, value: string): void {
+    if (this.throwOnSet) throw new Error("QuotaExceededError (simulated)");
+    this.store.set(key, value);
+  }
+  removeItem(key: string): void {
+    this.store.delete(key);
+  }
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+afterEach(() => {
+  // Clean up the global between tests so leakage can't mask bugs.
+  // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+  delete (globalThis as any).localStorage;
+});
+
+describe("deriveStorageKey", () => {
+  test("namespaces by apiUrl + cardKey under swarm:v1 prefix", () => {
+    expect(deriveStorageKey("http://localhost:3013", "home-welcome")).toBe(
+      "swarm:v1:http://localhost:3013:home-welcome",
+    );
+  });
+
+  test("two distinct apiUrls produce distinct keys for the same cardKey", () => {
+    const a = deriveStorageKey("http://a.local:3013", "home-welcome");
+    const b = deriveStorageKey("http://b.local:3013", "home-welcome");
+    expect(a).not.toBe(b);
+  });
+
+  test("two distinct cardKeys produce distinct keys for the same apiUrl", () => {
+    const a = deriveStorageKey("http://localhost:3013", "home-welcome");
+    const b = deriveStorageKey("http://localhost:3013", "setup:row:harness");
+    expect(a).not.toBe(b);
+  });
+
+  test("structured cardKey separators (colons) survive the round-trip", () => {
+    expect(deriveStorageKey("http://x", "setup:tour-complete")).toBe(
+      "swarm:v1:http://x:setup:tour-complete",
+    );
+  });
+});
+
+describe("dismiss / restore round-trip via localStorage shape", () => {
+  test("dismiss writes '1' under the namespaced key; restore removes it", () => {
+    const storage = new MemoryStorage();
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const key = deriveStorageKey("http://localhost:3013", "home-welcome");
+
+    // Initially undismissed.
+    expect(storage.getItem(key)).toBeNull();
+
+    // Simulate dismiss.
+    storage.setItem(key, "1");
+    expect(storage.getItem(key)).toBe("1");
+
+    // Simulate restore.
+    storage.removeItem(key);
+    expect(storage.getItem(key)).toBeNull();
+  });
+
+  test("namespace isolation: dismissing on apiUrl A does not affect apiUrl B", () => {
+    const storage = new MemoryStorage();
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const keyA = deriveStorageKey("http://a.local:3013", "home-welcome");
+    const keyB = deriveStorageKey("http://b.local:3013", "home-welcome");
+
+    storage.setItem(keyA, "1");
+
+    expect(storage.getItem(keyA)).toBe("1");
+    expect(storage.getItem(keyB)).toBeNull();
+  });
+});
+
+describe("graceful failure when localStorage throws", () => {
+  test("setItem throw is swallowed by the hook's try/catch contract", () => {
+    const storage = new MemoryStorage();
+    storage.setThrowOnSet(true);
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const key = deriveStorageKey("http://localhost:3013", "home-welcome");
+
+    // Direct call DOES throw — confirm the test shim is wired up.
+    expect(() => storage.setItem(key, "1")).toThrow();
+
+    // The hook contract is `try { localStorage.setItem(...) } catch {}` —
+    // emulate that wrapper and assert no error escapes to the caller.
+    const swallow = () => {
+      try {
+        storage.setItem(key, "1");
+      } catch {
+        // intentionally swallow
+      }
+    };
+    expect(swallow).not.toThrow();
+  });
+});

package/src/tools/memory-rate.ts

@@ -0,0 +1,166 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { REFERENCES_SOURCE_MAX_LENGTH, sanitizeReferencesSource } from "@/be/memory/raters/types";
+import { createToolRegistrar } from "@/tools/utils";
+
+/**
+ * Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-5.md §1
+ *       thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-6.md §5
+ *
+ * Worker-facing MCP tool. Posts a single explicit-self `RatingEvent` to the
+ * existing `POST /api/memory/rate` endpoint shipped in step-3 and surfaces
+ * server status codes as structured `{ success, message }` output instead of
+ * throwing — so an agent that mis-uses the tool gets a clear, recoverable
+ * answer rather than a tool-call exception.
+ *
+ * Step-6 added the optional `referencesSource` field — Q2 free-form contract:
+ * ≤512 chars, control-char strip, NUL byte rejection. Convention-only shape
+ * `<source>:<identifier>` is documentation, NOT enforcement.
+ */
+
+const DUPLICATE_MESSAGE =
+  "Memory already rated for this task. Use a follow-up memory_rerate tool (coming soon) to override.";
+
+const REFERENCES_SOURCE_DESCRIPTION =
+  "Optional external source ID this memory references. Free-form string, " +
+  'convention "<source>:<identifier>" (e.g. "github:owner/repo#N", ' +
+  '"linear:KEY-N", "customer:<slug>", "slack:<channel>:<ts>", ' +
+  '"agentmail:<thread-id>"). Pick any prefix that fits — no closed enum. ' +
+  "When present, an edge from this memory to the external source is " +
+  "created/updated.";
+
+export const registerMemoryRateTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "memory_rate",
+    {
+      title: "Rate a memory",
+      description:
+        "Rate a memory you used in the current task. Call this when a " +
+        "retrieved memory was clearly useful (or actively misleading) so " +
+        "the swarm learns to surface better memories next time.",
+      annotations: { destructiveHint: false },
+      inputSchema: z.object({
+        id: z.string().describe("Memory ID returned by memory_search."),
+        useful: z
+          .boolean()
+          .describe("true = this memory helped solve the task; false = misled or wasted time."),
+        note: z
+          .string()
+          .max(280)
+          .optional()
+          .describe("Short reason. Captured for telemetry; not surfaced to other agents."),
+        referencesSource: z
+          .string()
+          .min(1)
+          .max(REFERENCES_SOURCE_MAX_LENGTH)
+          .optional()
+          .describe(REFERENCES_SOURCE_DESCRIPTION),
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+      }),
+    },
+    async ({ id, useful, note, referencesSource }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        const msg = "Agent ID required. Are you registered in the swarm?";
+        return {
+          content: [{ type: "text", text: msg }],
+          structuredContent: { success: false, message: msg },
+        };
+      }
+      if (!requestInfo.sourceTaskId) {
+        const msg = "memory_rate must be called from within a task — no source task ID was found.";
+        return {
+          content: [{ type: "text", text: msg }],
+          structuredContent: { success: false, message: msg },
+        };
+      }
+
+      let cleanedReferencesSource: string | undefined;
+      if (referencesSource !== undefined) {
+        const cleaned = sanitizeReferencesSource(referencesSource);
+        if (cleaned === null) {
+          const msg =
+            "referencesSource must not contain NUL bytes or strip to empty after control-char removal.";
+          return {
+            content: [{ type: "text", text: msg }],
+            structuredContent: { success: false, message: msg },
+          };
+        }
+        cleanedReferencesSource = cleaned;
+      }
+
+      const apiUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
+      const apiKey = process.env.API_KEY || "";
+
+      const event = {
+        memoryId: id,
+        signal: useful ? 1 : -1,
+        weight: 1.0,
+        source: "explicit-self" as const,
+        reasoning: note ?? "",
+        taskId: requestInfo.sourceTaskId,
+        ...(cleanedReferencesSource !== undefined
+          ? { referencesSource: cleanedReferencesSource }
+          : {}),
+      };
+
+      try {
+        const response = await fetch(`${apiUrl}/api/memory/rate`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            "X-Agent-ID": requestInfo.agentId,
+          },
+          body: JSON.stringify({ events: [event] }),
+        });
+
+        if (response.status === 409) {
+          return {
+            content: [{ type: "text", text: DUPLICATE_MESSAGE }],
+            structuredContent: { success: false, message: DUPLICATE_MESSAGE },
+          };
+        }
+
+        if (response.status === 400) {
+          let serverError = "";
+          try {
+            const body = (await response.json()) as { error?: string };
+            serverError = body?.error ?? "";
+          } catch {
+            // body wasn't JSON
+          }
+          const msg = serverError
+            ? `Memory rating rejected: ${serverError}. The memory must have been retrieved by this task before it can be rated.`
+            : "Memory rating rejected. The memory must have been retrieved by this task before it can be rated.";
+          return {
+            content: [{ type: "text", text: msg }],
+            structuredContent: { success: false, message: msg },
+          };
+        }
+
+        if (!response.ok) {
+          const msg = `Memory rating failed (HTTP ${response.status}).`;
+          return {
+            content: [{ type: "text", text: msg }],
+            structuredContent: { success: false, message: msg },
+          };
+        }
+
+        const successMsg = `Memory ${id} rated as ${useful ? "useful" : "not useful"}.`;
+        return {
+          content: [{ type: "text", text: successMsg }],
+          structuredContent: { success: true, message: successMsg },
+        };
+      } catch (err) {
+        const msg = `Memory rating failed: ${(err as Error).message}`;
+        return {
+          content: [{ type: "text", text: msg }],
+          structuredContent: { success: false, message: msg },
+        };
+      }
+    },
+  );
+};

package/src/tools/memory-search.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
 import { CANDIDATE_SET_MULTIPLIER } from "@/be/memory/constants";
+import { recordRetrievals } from "@/be/memory/raters/retrieval";
 import { rerank } from "@/be/memory/reranker";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentMemoryScopeSchema, AgentMemorySourceSchema } from "@/types";
@@ -76,6 +77,23 @@ export const registerMemorySearchTool = (server: McpServer) => {
         });
         const ranked = rerank(candidates, { limit });
 
+        // Retrieval bridge — when called inside a task scope, log one
+        // `memory_retrieval` row per returned memory so server-side raters
+        // (ImplicitCitationRater) can score them at task completion.
+        // Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-2.md §3
+        if (requestInfo.sourceTaskId) {
+          try {
+            recordRetrievals(
+              requestInfo.sourceTaskId,
+              requestInfo.agentId,
+              ranked.map((r) => ({ memoryId: r.id, similarity: r.similarity })),
+              requestInfo.sessionId,
+            );
+          } catch (err) {
+            console.error("[memory-search] recordRetrievals failed:", (err as Error).message);
+          }
+        }
+
         const mapped = ranked.map((r) => ({
           id: r.id,
           name: r.name,

package/src/tools/store-progress.ts

@@ -9,11 +9,14 @@ import {
   getAgentById,
   getDb,
   getLeadAgent,
+  getSessionLogsByTaskId,
   getTaskById,
   updateAgentStatusFromCapacity,
   updateTaskProgress,
 } from "@/be/db";
 import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { getRetrievalsForTask } from "@/be/memory/raters/retrieval";
+import { runServerRaters } from "@/be/memory/raters/run-server-raters";
 import { resolveTemplate } from "@/prompts/resolver";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentTaskSchema } from "@/types";
@@ -356,6 +359,40 @@ export const registerStoreProgressTool = (server: McpServer) => {
             // Non-blocking — task completion memory failure should not affect task status
           }
         })();
+
+        // Memory rater v1.5 — fire server-side raters on task completion.
+        // Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-2.md §5
+        //
+        // Read `memory_retrieval` rows for this task + concatenated session_logs
+        // and hand both to `runServerRaters`, which iterates the allow-listed
+        // server raters (currently just `implicit-citation`), stamps source,
+        // applies the configured weight multiplier, and persists via
+        // `applyRating`. The orchestration is extracted so it can be unit-tested
+        // with stub raters (see `src/tests/run-server-raters.test.ts`).
+        //
+        // Fire-and-forget: rater failure must NEVER affect task status.
+        (async () => {
+          try {
+            const retrievals = getRetrievalsForTask(taskId);
+            if (retrievals.length === 0) return;
+
+            const retrievedMemoryIds = retrievals.map((r) => r.memoryId);
+            const logs = getSessionLogsByTaskId(taskId);
+            const evidence = logs.map((l) => l.content).join("\n");
+
+            await runServerRaters({
+              taskId,
+              agentId: requestInfo.agentId ?? "",
+              retrievedMemoryIds,
+              evidence,
+            });
+          } catch (err) {
+            console.error(
+              "[store-progress] server-rater fire failed:",
+              err instanceof Error ? err.message : String(err),
+            );
+          }
+        })();
       }
 
       // Create follow-up task for the lead when a worker task finishes.

package/src/tools/swarm-config/set-config.ts

@@ -1,7 +1,11 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { maskSecrets, upsertSwarmConfig } from "@/be/db";
-import { isReservedConfigKey, reservedKeyError } from "@/be/swarm-config-guard";
+import {
+  isReservedConfigKey,
+  reservedKeyError,
+  validateConfigValue,
+} from "@/be/swarm-config-guard";
 import { createToolRegistrar } from "@/tools/utils";
 import { SwarmConfigSchema, SwarmConfigScopeSchema } from "@/types";
 
@@ -89,6 +93,18 @@ export const registerSetConfigTool = (server: McpServer) => {
           };
         }
 
+        const validationError = validateConfigValue(key, value);
+        if (validationError) {
+          return {
+            content: [{ type: "text", text: validationError }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: validationError,
+            },
+          };
+        }
+
         const config = upsertSwarmConfig({
           scope,
           scopeId: scope === "global" ? null : scopeId,