@desplega.ai/agent-swarm 1.93.0 → 1.94.0

package/src/tests/seed.test.ts

@@ -1,7 +1,13 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
-import { getSeedState, runSeeder, type Seeder, type SeedItem } from "../be/seed";
+import {
+  getSeedState,
+  runSeeder,
+  type Seeder,
+  type SeederRunOptions,
+  type SeedItem,
+} from "../be/seed";
 
 const TEST_DB_PATH = "./test-seed.sqlite";
 
@@ -137,6 +143,25 @@ describe("seeder harness — versioning rule", () => {
     expect(upstream.get("y")).toBe("h-pre-existing");
   });
 
+  test("runner passes opts through to apply()", async () => {
+    const capturedOpts: (SeederRunOptions | undefined)[] = [];
+    const source = new Map([["a", "h-a1"]]);
+    const upstream = new Map<string, string>();
+    const seeder: Seeder<SeedItem> = {
+      kind: "opts-passthrough-test",
+      items: () => [...source.entries()].map(([key, contentHash]) => ({ key, contentHash })),
+      upstreamHash: (item) => upstream.get(item.key) ?? null,
+      apply: (item, _action, opts) => {
+        capturedOpts.push(opts);
+        upstream.set(item.key, item.contentHash);
+      },
+    };
+
+    await runSeeder(seeder, { quiet: true, scriptEmbeddingMode: "skip" });
+    expect(capturedOpts).toHaveLength(1);
+    expect(capturedOpts[0]?.scriptEmbeddingMode).toBe("skip");
+  });
+
   test("a throwing apply is captured per-item without aborting the run", async () => {
     const source = new Map([
       ["ok", "h-ok"],

package/src/tests/session-costs-model-key-normalize.test.ts

@@ -134,6 +134,8 @@ describe("normalizeModelKey()", () => {
 
   test("is a no-op for canonical claude ids", () => {
     expect(normalizeModelKey("claude", "claude-opus-4-7")).toBe("claude-opus-4-7");
+    expect(normalizeModelKey("claude", "claude-fable-5")).toBe("claude-fable-5");
+    expect(normalizeModelKey("claude", "claude-mythos-5")).toBe("claude-mythos-5");
   });
 
   test("is idempotent", () => {

package/src/tests/slack-watcher.test.ts

@@ -9,12 +9,16 @@ import {
   getChildTasks,
   getCompletedSlackTasks,
   getInProgressSlackTasks,
+  getTaskById,
   initDb,
   insertTaskAttachment,
+  setSlackMessageTracking,
   startTask,
+  updateTaskProgress,
 } from "../be/db";
 import {
   _getLastRenderedTree,
+  _getTaskMessages,
   _getTaskToTree,
   _getTreeLastUpdateTime,
   _getTreeMessages,
@@ -114,6 +118,68 @@ describe("watcher DB queries", () => {
     startTaskWatcher(60000);
     stopTaskWatcher();
   });
+
+  test("rehydrates tree message tracking from in-progress tasks after restart", () => {
+    const agent = createAgent({ name: "WatcherHydrateTreeAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("watcher hydrate tree test", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_HYDRATE_TREE",
+      slackThreadTs: "1919191919.000001",
+      slackUserId: "U_HYDRATE_TREE",
+    });
+    startTask(task.id);
+
+    const messageTs = "1919191919.000002";
+    registerTreeMessage(task.id, "C_HYDRATE_TREE", "1919191919.000001", messageTs);
+
+    expect(getTaskById(task.id)!.slackTreeRootMessageTs).toBe(messageTs);
+
+    _getTreeMessages().clear();
+    _getTaskToTree().clear();
+    _getTaskMessages().clear();
+
+    startTaskWatcher(60000);
+    stopTaskWatcher();
+
+    const tree = _getTreeMessages().get(messageTs);
+    expect(tree).toBeDefined();
+    expect(tree!.channelId).toBe("C_HYDRATE_TREE");
+    expect(tree!.threadTs).toBe("1919191919.000001");
+    expect(tree!.rootTaskIds.has(task.id)).toBe(true);
+    expect(_getTaskToTree().get(task.id)).toBe(messageTs);
+    expect(_getTaskMessages().get(task.id)?.messageTs).toBe(messageTs);
+  });
+
+  test("rehydrates flat progress message tracking from in-progress tasks after restart", () => {
+    const agent = createAgent({ name: "WatcherHydrateFlatAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("watcher hydrate flat test", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_HYDRATE_FLAT",
+      slackThreadTs: "2020202020.000001",
+      slackUserId: "U_HYDRATE_FLAT",
+    });
+    updateTaskProgress(task.id, "Halfway there");
+
+    const messageTs = "2020202020.000002";
+    setSlackMessageTracking(task.id, { slackProgressMessageTs: messageTs });
+
+    _getTreeMessages().clear();
+    _getTaskToTree().clear();
+    _getTaskMessages().clear();
+
+    startTaskWatcher(60000);
+    stopTaskWatcher();
+
+    expect(_getTreeMessages().has(messageTs)).toBe(false);
+    expect(_getTaskToTree().has(task.id)).toBe(false);
+    expect(_getTaskMessages().get(task.id)).toEqual({
+      channelId: "C_HYDRATE_FLAT",
+      threadTs: "2020202020.000001",
+      messageTs,
+    });
+  });
 });
 
 describe("getChildTasks", () => {

package/src/tests/workflow-agent-task.test.ts

@@ -94,13 +94,14 @@ afterAll(async () => {
 // ─── Tests ───────────────────────────────────────────────────
 
 describe("AgentTaskExecutor — workspace scoping", () => {
-  test("config schema accepts dir, vcsRepo, model, parentTaskId", () => {
+  test("config schema accepts dir, vcsRepo, model, modelTier, parentTaskId", () => {
     const executor = new AgentTaskExecutor(mockDeps);
     const config = {
       template: "Do something",
       dir: "/workspace/repos/my-project",
       vcsRepo: "org/repo",
       model: "sonnet",
+      modelTier: "smart",
       parentTaskId: "f1b14078-5df1-457d-88a2-33f1d3e621fd",
     };
     const parsed = executor.configSchema.safeParse(config);
@@ -109,6 +110,7 @@ describe("AgentTaskExecutor — workspace scoping", () => {
       expect(parsed.data.dir).toBe("/workspace/repos/my-project");
       expect(parsed.data.vcsRepo).toBe("org/repo");
       expect(parsed.data.model).toBe("sonnet");
+      expect(parsed.data.modelTier).toBe("smart");
       expect(parsed.data.parentTaskId).toBe("f1b14078-5df1-457d-88a2-33f1d3e621fd");
     }
   });
@@ -166,7 +168,8 @@ describe("AgentTaskExecutor — workspace scoping", () => {
     expect(task).toBeDefined();
     expect(task!.dir).toBe("/workspace/repos/agent-swarm");
     expect(task!.vcsRepo).toBe("desplega-ai/agent-swarm");
-    expect(task!.model).toBe("sonnet");
+    expect(task!.model).toBeUndefined();
+    expect(task!.modelTier).toBe("regular");
     expect(task!.source).toBe("workflow");
   });
 

package/src/tests/workflow-validation-port-routing.test.ts

@@ -47,6 +47,29 @@ class ObjectOutputExecutor extends BaseExecutor<
   }
 }
 
+/**
+ * Executor that mimics an agent-task review output shape.
+ * Used for regression coverage around aliased property-match fields.
+ */
+class ReviewOutputExecutor extends BaseExecutor<
+  typeof ReviewOutputExecutor.schema,
+  typeof ReviewOutputExecutor.outSchema
+> {
+  static readonly schema = z.object({ verdict: z.string() });
+  static readonly outSchema = z.object({ taskOutput: z.object({ verdict: z.string() }) });
+
+  readonly type = "review-output";
+  readonly mode = "instant" as const;
+  readonly configSchema = ReviewOutputExecutor.schema;
+  readonly outputSchema = ReviewOutputExecutor.outSchema;
+
+  protected async execute(
+    config: z.infer<typeof ReviewOutputExecutor.schema>,
+  ): Promise<ExecutorResult<z.infer<typeof ReviewOutputExecutor.outSchema>>> {
+    return { status: "success", output: { taskOutput: { verdict: config.verdict } } };
+  }
+}
+
 /**
  * Terminal executor that just succeeds. Used for leaf nodes.
  */
@@ -77,6 +100,7 @@ const mockDeps: ExecutorDependencies = {
 function createTestRegistry(): ExecutorRegistry {
   const registry = new ExecutorRegistry();
   registry.register(new ObjectOutputExecutor(mockDeps));
+  registry.register(new ReviewOutputExecutor(mockDeps));
   registry.register(new NoopExecutor(mockDeps));
   registry.register(new PropertyMatchExecutor(mockDeps));
   return registry;
@@ -218,4 +242,161 @@ describe("Validation Port Routing", () => {
     const run = getWorkflowRun(runId);
     expect(run!.status).toBe("completed");
   });
+
+  test("property-match node resolves fields through node.inputs aliases", async () => {
+    const workflow = makeWorkflow({
+      nodes: [
+        {
+          id: "review-step",
+          type: "object-output",
+          config: { approved: true },
+          next: "check",
+        },
+        {
+          id: "check",
+          type: "property-match",
+          inputs: { review: "review-step" },
+          config: {
+            conditions: [{ field: "review.approved", op: "eq", value: true }],
+          },
+          next: { true: "on-pass", false: "on-fail" },
+        },
+        {
+          id: "on-pass",
+          type: "noop",
+          config: {},
+        },
+        {
+          id: "on-fail",
+          type: "noop",
+          config: {},
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    expect(nodeIds).toContain("check");
+    expect(nodeIds).toContain("on-pass");
+    expect(nodeIds).not.toContain("on-fail");
+  });
+
+  test("property-match node keeps raw context path fallback with node.inputs present", async () => {
+    const workflow = makeWorkflow({
+      nodes: [
+        {
+          id: "review-step",
+          type: "object-output",
+          config: { approved: true },
+          next: "check",
+        },
+        {
+          id: "check",
+          type: "property-match",
+          inputs: { review: "review-step" },
+          config: {
+            conditions: [{ field: "review-step.approved", op: "eq", value: true }],
+          },
+          next: { true: "on-pass", false: "on-fail" },
+        },
+        {
+          id: "on-pass",
+          type: "noop",
+          config: {},
+        },
+        {
+          id: "on-fail",
+          type: "noop",
+          config: {},
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    expect(nodeIds).toContain("on-pass");
+    expect(nodeIds).not.toContain("on-fail");
+  });
+
+  test("property-match handles DES-294 review.taskOutput.verdict alias shape", async () => {
+    const workflow = makeWorkflow({
+      nodes: [
+        {
+          id: "review-step",
+          type: "review-output",
+          config: { verdict: "continue" },
+          next: "halt-check",
+        },
+        {
+          id: "halt-check",
+          type: "property-match",
+          inputs: { review: "review-step" },
+          config: {
+            conditions: [{ field: "review.taskOutput.verdict", op: "eq", value: "continue" }],
+          },
+          next: { true: "continue-flow", false: "false-halt" },
+        },
+        {
+          id: "continue-flow",
+          type: "noop",
+          config: {},
+        },
+        {
+          id: "false-halt",
+          type: "noop",
+          config: {},
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    expect(nodeIds).toContain("continue-flow");
+    expect(nodeIds).not.toContain("false-halt");
+  });
+
+  test("property-match validation resolves fields through node.inputs aliases", async () => {
+    const workflow = makeWorkflow({
+      nodes: [
+        {
+          id: "check",
+          type: "object-output",
+          inputs: { review: "trigger.review" },
+          config: { approved: true },
+          next: "after-check",
+          validation: {
+            executor: "property-match",
+            config: {
+              conditions: [{ field: "review.taskOutput.verdict", op: "eq", value: "continue" }],
+            },
+            mustPass: true,
+          },
+        },
+        {
+          id: "after-check",
+          type: "noop",
+          config: {},
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(
+      workflow,
+      { review: { taskOutput: { verdict: "continue" } } },
+      registry,
+    );
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+    const run = getWorkflowRun(runId);
+
+    expect(run!.status).toBe("completed");
+    expect(nodeIds).toContain("check");
+    expect(nodeIds).toContain("after-check");
+  });
 });

package/src/tools/memory-get.ts

@@ -2,8 +2,11 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getMemoryStore } from "@/be/memory";
 import { createToolRegistrar } from "@/tools/utils";
+import type { AgentMemorySource } from "@/types";
 import { AgentMemorySchema } from "@/types";
 
+const NUDGE_ELIGIBLE_SOURCES: ReadonlySet<AgentMemorySource> = new Set(["manual", "file_index"]);
+
 export const registerMemoryGetTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "memory-get",
@@ -21,6 +24,7 @@ export const registerMemoryGetTool = (server: McpServer) => {
         success: z.boolean(),
         message: z.string(),
         memory: AgentMemorySchema.optional(),
+        rateHint: z.string().optional(),
       }),
     },
     async ({ memoryId }, requestInfo, _meta) => {
@@ -37,6 +41,12 @@ export const registerMemoryGetTool = (server: McpServer) => {
         };
       }
 
+      const inTaskContext = !!requestInfo.sourceTaskId;
+      const rateHint =
+        inTaskContext && NUDGE_ELIGIBLE_SOURCES.has(memory.source as AgentMemorySource)
+          ? `memory_rate(id="${memory.id}", useful=true|false)`
+          : undefined;
+
       return {
         content: [
           {
@@ -49,6 +59,7 @@ export const registerMemoryGetTool = (server: McpServer) => {
           success: true,
           message: `Memory "${memory.name}" retrieved.`,
           memory,
+          rateHint,
         },
       };
     },

package/src/tools/memory-search.ts

@@ -6,8 +6,15 @@ 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 type { AgentMemorySource } from "@/types";
 import { AgentMemoryScopeSchema, AgentMemorySourceSchema } from "@/types";
 
+const NUDGE_ELIGIBLE_SOURCES: ReadonlySet<AgentMemorySource> = new Set(["manual", "file_index"]);
+
+function rateHintFor(memoryId: string): string {
+  return `memory_rate(id="${memoryId}", useful=true|false)`;
+}
+
 export const registerMemorySearchTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "memory-search",
@@ -42,9 +49,11 @@ export const registerMemorySearchTool = (server: McpServer) => {
               scope: AgentMemoryScopeSchema,
               similarity: z.number().optional(),
               createdAt: z.string(),
+              rateHint: z.string().optional(),
             }),
           )
           .optional(),
+        _ratingNudge: z.string().optional(),
       }),
     },
     async ({ query, scope, limit, source }, requestInfo, _meta) => {
@@ -94,6 +103,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
           }
         }
 
+        const inTaskContext = !!requestInfo.sourceTaskId;
         const mapped = ranked.map((r) => ({
           id: r.id,
           name: r.name,
@@ -102,8 +112,15 @@ export const registerMemorySearchTool = (server: McpServer) => {
           scope: r.scope,
           similarity: r.similarity,
           createdAt: r.createdAt,
+          ...(inTaskContext && NUDGE_ELIGIBLE_SOURCES.has(r.source as AgentMemorySource)
+            ? { rateHint: rateHintFor(r.id) }
+            : {}),
         }));
 
+        const nudgeCount = mapped.filter((r) => r.rateHint).length;
+        const _ratingNudge =
+          nudgeCount > 0 ? "Rate memories that help or mislead you with memory_rate." : undefined;
+
         return {
           content: [
             {
@@ -116,6 +133,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
             success: true,
             message: `Found ${mapped.length} memories matching "${query}".`,
             results: mapped,
+            _ratingNudge,
           },
         };
       }

package/src/tools/schedules/create-schedule.ts

@@ -4,6 +4,71 @@ import * as z from "zod";
 import { createScheduledTask, getAgentById, getScheduledTaskByName } from "@/be/db";
 import { calculateNextRun } from "@/scheduler";
 import { createToolRegistrar } from "@/tools/utils";
+import { ModelTierSchema, splitLegacyModelAlias } from "../../model-tiers";
+
+export const createScheduleInputSchema = z.object({
+  name: z.string().min(1).max(100).describe("Unique name for the schedule (e.g., 'daily-cleanup')"),
+  taskTemplate: z.string().min(1).describe("The task description that will be created each time"),
+  scheduleType: z
+    .enum(["recurring", "one_time"])
+    .default("recurring")
+    .optional()
+    .describe("Schedule type: 'recurring' (default) or 'one_time'"),
+  cronExpression: z
+    .string()
+    .optional()
+    .describe("Cron expression for recurring schedules (e.g., '0 9 * * *')"),
+  intervalMs: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Interval in milliseconds for recurring schedules (e.g., 3600000 for hourly)"),
+  delayMs: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Delay in milliseconds for one-time schedules (e.g., 1800000 for 30 min)"),
+  runAt: z
+    .string()
+    .datetime()
+    .optional()
+    .describe("ISO datetime for one-time schedules (e.g., '2026-03-06T15:00:00Z')"),
+  description: z.string().optional().describe("Human-readable description of the schedule"),
+  taskType: z.string().max(50).optional().describe("Task type (e.g., 'maintenance', 'report')"),
+  tags: z.array(z.string()).optional().describe("Tags to apply to created tasks"),
+  priority: z
+    .number()
+    .int()
+    .min(0)
+    .max(100)
+    .default(50)
+    .optional()
+    .describe("Task priority 0-100 (default: 50)"),
+  targetAgentId: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Agent to assign tasks to (omit for task pool)"),
+  timezone: z.string().default("UTC").optional().describe("Timezone for cron schedules"),
+  enabled: z
+    .boolean()
+    .default(true)
+    .optional()
+    .describe("Whether the schedule is enabled (default: true)"),
+  model: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe(
+      "Concrete model override for tasks created by this schedule. Interpreted by each assignee's harness/provider and does not switch providers. Prefer modelTier for portable intent.",
+    ),
+  modelTier: ModelTierSchema.optional().describe(
+    "Portable model tier for tasks created by this schedule: 'smol', 'regular', 'smart', or 'ultra'. Resolved by each assignee's harness/provider at run time.",
+  ),
+});
 
 export const registerCreateScheduleTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -13,75 +78,7 @@ export const registerCreateScheduleTool = (server: McpServer) => {
       annotations: { destructiveHint: false },
       description:
         "Create a new scheduled task. For recurring: provide cronExpression or intervalMs. For one-time: provide delayMs or runAt with scheduleType 'one_time'.",
-      inputSchema: z.object({
-        name: z
-          .string()
-          .min(1)
-          .max(100)
-          .describe("Unique name for the schedule (e.g., 'daily-cleanup')"),
-        taskTemplate: z
-          .string()
-          .min(1)
-          .describe("The task description that will be created each time"),
-        scheduleType: z
-          .enum(["recurring", "one_time"])
-          .default("recurring")
-          .optional()
-          .describe("Schedule type: 'recurring' (default) or 'one_time'"),
-        cronExpression: z
-          .string()
-          .optional()
-          .describe("Cron expression for recurring schedules (e.g., '0 9 * * *')"),
-        intervalMs: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Interval in milliseconds for recurring schedules (e.g., 3600000 for hourly)"),
-        delayMs: z
-          .number()
-          .int()
-          .positive()
-          .optional()
-          .describe("Delay in milliseconds for one-time schedules (e.g., 1800000 for 30 min)"),
-        runAt: z
-          .string()
-          .datetime()
-          .optional()
-          .describe("ISO datetime for one-time schedules (e.g., '2026-03-06T15:00:00Z')"),
-        description: z.string().optional().describe("Human-readable description of the schedule"),
-        taskType: z
-          .string()
-          .max(50)
-          .optional()
-          .describe("Task type (e.g., 'maintenance', 'report')"),
-        tags: z.array(z.string()).optional().describe("Tags to apply to created tasks"),
-        priority: z
-          .number()
-          .int()
-          .min(0)
-          .max(100)
-          .default(50)
-          .optional()
-          .describe("Task priority 0-100 (default: 50)"),
-        targetAgentId: z
-          .string()
-          .uuid()
-          .optional()
-          .describe("Agent to assign tasks to (omit for task pool)"),
-        timezone: z.string().default("UTC").optional().describe("Timezone for cron schedules"),
-        enabled: z
-          .boolean()
-          .default(true)
-          .optional()
-          .describe("Whether the schedule is enabled (default: true)"),
-        model: z
-          .enum(["haiku", "sonnet", "opus", "fable"])
-          .optional()
-          .describe(
-            "Model to use for tasks created by this schedule ('haiku', 'sonnet', 'opus', or 'fable'). If not set, uses agent/global config or defaults to 'opus'.",
-          ),
-      }),
+      inputSchema: createScheduleInputSchema,
       outputSchema: z.object({
         yourAgentId: z.string().uuid().optional(),
         success: z.boolean(),
@@ -104,6 +101,7 @@ export const registerCreateScheduleTool = (server: McpServer) => {
             createdByAgentId: z.string().optional(),
             timezone: z.string(),
             model: z.string().optional(),
+            modelTier: ModelTierSchema.optional(),
             scheduleType: z.string(),
             createdAt: z.string(),
             lastUpdatedAt: z.string(),
@@ -128,6 +126,7 @@ export const registerCreateScheduleTool = (server: McpServer) => {
         timezone,
         enabled,
         model,
+        modelTier,
       },
       requestInfo,
       _meta,
@@ -270,6 +269,7 @@ export const registerCreateScheduleTool = (server: McpServer) => {
       }
 
       try {
+        const normalizedModel = splitLegacyModelAlias({ model, modelTier });
         // Calculate initial nextRunAt
         let nextRunAt: string | undefined;
         if (enabled === false) {
@@ -299,7 +299,8 @@ export const registerCreateScheduleTool = (server: McpServer) => {
           enabled,
           nextRunAt,
           createdByAgentId: requestInfo.agentId,
-          model,
+          model: normalizedModel.model,
+          modelTier: normalizedModel.modelTier,
           scheduleType: scheduleType ?? "recurring",
         });