@desplega.ai/agent-swarm 1.102.0 → 1.103.0

package/src/http/tasks.ts

@@ -23,7 +23,6 @@ import {
   updateTaskProgress,
   updateTaskVcs,
 } from "../be/db";
-import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import {
@@ -32,8 +31,10 @@ import {
   type AgentTaskStatus,
   AgentTaskStatusSchema,
   isTerminalTaskStatus,
+  ModelTierSchema,
   ProviderNameSchema,
   ResumeReasonSchema,
+  splitLegacyModelAlias,
 } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { route } from "./route-def";

package/src/http/workflows.ts

@@ -663,6 +663,7 @@ export async function handleWorkflows(
     let runId: string;
     try {
       runId = await startWorkflowExecution(workflow, body, getExecutorRegistry(), {
+        triggerType: "api",
         requestedByUserId: auth?.kind === "user" ? auth.userId : undefined,
       });
     } catch (err) {

package/src/prompts/resolver.ts

@@ -8,7 +8,7 @@
  *   workers which have no local database (architecture invariant: workers communicate via HTTP only).
  */
 
-import { interpolate } from "../workflows/template";
+import { interpolate } from "../utils/template";
 import { getTemplateDefinition } from "./registry";
 
 // ─── DB Resolver Injection ──────────────────────────────────────────────────

package/src/scheduler/scheduler.ts

@@ -3,6 +3,7 @@ import { CronExpressionParser } from "cron-parser";
 import { getDb, getDueScheduledTasks, getScheduledTaskById, updateScheduledTask } from "@/be/db";
 import { scheduleContextKey } from "@/tasks/context-key";
 import { createTaskWithSiblingAwareness } from "@/tasks/sibling-awareness";
+import { telemetry } from "@/telemetry";
 import type { AgentTask, ScheduledTask } from "@/types";
 import type { ExecutorRegistry } from "@/workflows/executors/registry";
 import { handleScheduleTrigger } from "@/workflows/triggers";
@@ -48,9 +49,9 @@ async function recoverMissedSchedules(): Promise<void> {
         `(was due ${Math.round(missedBy / 1000)}s ago)`,
     );
 
+    let triggeredWorkflows = false;
     try {
       // Check if any workflows are linked to this schedule
-      let triggeredWorkflows = false;
       if (executorRegistry) {
         const runIds = await handleScheduleTrigger(schedule.id, schedule, executorRegistry);
         if (runIds.length > 0) {
@@ -88,7 +89,18 @@ async function recoverMissedSchedules(): Promise<void> {
       if (schedule.scheduleType === "one_time") {
         console.log(`[Scheduler] One-time schedule "${schedule.name}" recovered and auto-disabled`);
       }
+      telemetry.schedule("executed", {
+        scheduleType: schedule.scheduleType,
+        triggeredWorkflows,
+        wasRecovered: true,
+      });
     } catch (err) {
+      telemetry.schedule("error", {
+        scheduleType: schedule.scheduleType,
+        triggeredWorkflows,
+        wasRecovered: true,
+        consecutiveErrors: schedule.consecutiveErrors ?? 0,
+      });
       console.error(`[Scheduler] Error recovering "${schedule.name}":`, err);
     }
   }
@@ -142,9 +154,9 @@ function getBackoffMs(consecutiveErrors: number): number {
  * Tracks consecutive errors and applies exponential backoff on failure.
  */
 async function executeSchedule(schedule: ScheduledTask): Promise<void> {
+  let triggeredWorkflows = false;
   try {
     // Check if any workflows are linked to this schedule
-    let triggeredWorkflows = false;
     if (executorRegistry) {
       const runIds = await handleScheduleTrigger(schedule.id, schedule, executorRegistry);
       if (runIds.length > 0) {
@@ -187,6 +199,11 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
       });
       console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
     }
+    telemetry.schedule("executed", {
+      scheduleType: schedule.scheduleType,
+      triggeredWorkflows,
+      wasRecovered: false,
+    });
   } catch (err) {
     const errorCount = (schedule.consecutiveErrors ?? 0) + 1;
     const now = new Date();
@@ -228,6 +245,12 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
     }
 
     updateScheduledTask(schedule.id, updates);
+    telemetry.schedule("error", {
+      scheduleType: schedule.scheduleType,
+      triggeredWorkflows,
+      wasRecovered: false,
+      consecutiveErrors: errorCount,
+    });
   }
 }
 

package/src/server-runtime-counters.ts

@@ -0,0 +1,12 @@
+const runtimeCounters = globalThis as typeof globalThis & {
+  __agentSwarmServerSessionsProcessed?: number;
+};
+
+export function incrementServerSessionsProcessed(): void {
+  runtimeCounters.__agentSwarmServerSessionsProcessed =
+    (runtimeCounters.__agentSwarmServerSessionsProcessed ?? 0) + 1;
+}
+
+export function getServerSessionsProcessed(): number {
+  return runtimeCounters.__agentSwarmServerSessionsProcessed ?? 0;
+}

package/src/server-user.ts

@@ -1,7 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import pkg from "../package.json";
-import { ModelTierSchema } from "./model-tiers";
 import {
   cancelTaskHandler,
   cancelTaskInputSchema,
@@ -21,7 +20,7 @@ import {
 } from "./tools/task-action";
 import { userCtx } from "./tools/task-tool-ctx";
 import { createToolRegistrar } from "./tools/utils";
-import type { User } from "./types";
+import { ModelTierSchema, type User } from "./types";
 
 const userSendTaskInputSchema = z.object({
   task: z.string().min(1).describe("The task description to send."),

package/src/server.ts

@@ -3,6 +3,7 @@ import pkg from "../package.json";
 import { initDb } from "./be/db";
 import { startPricingRefreshLoop } from "./be/pricing-refresh";
 import { seedPricingFromModelsDev } from "./be/seed-pricing";
+import { registerGithubTaskReactions } from "./github/task-reactions";
 import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
@@ -175,6 +176,10 @@ export function createServer() {
   seedPricingFromModelsDev();
   startPricingRefreshLoop();
 
+  // Subscribe API-side integrations to task-lifecycle events. Idempotent.
+  // (Inverts the old be/db → github/task-reactions import; see cycle-break #4.)
+  registerGithubTaskReactions();
+
   const server = new McpServer(
     {
       name: pkg.name,

package/src/telemetry.ts

@@ -7,6 +7,7 @@
  * - Importable from both API server and workers
  */
 import { randomUUID } from "node:crypto";
+import pkg from "../package.json";
 
 const TELEMETRY_ENDPOINT = "https://proxy.desplega.sh/v1/events";
 const PRODUCT = "agent-swarm";
@@ -195,6 +196,7 @@ export function track(options: TrackOptions): void {
         // anonymous, and the boolean is sufficient to split cloud vs self-host.
         is_cloud: cachedIsCloud,
         is_e2b: cachedIsE2b,
+        swarmVersion: pkg.version,
       },
       metadata: {
         transport: "https",
@@ -238,7 +240,6 @@ export const telemetry = {
     props: {
       taskId: string;
       source?: string;
-      tags?: string[];
       durationMs?: number;
       hasParent?: boolean;
       agentId?: string;
@@ -256,4 +257,20 @@ export const telemetry = {
   session(event: string, props: { agentId: string; taskId?: string; [k: string]: unknown }): void {
     track({ event: `session.${event}`, properties: props });
   },
+
+  schedule(event: string, props: Record<string, unknown>): void {
+    track({ event: `schedule.${event}`, properties: props });
+  },
+
+  workflow(event: string, props: Record<string, unknown>): void {
+    track({ event: `workflow.${event}`, properties: props });
+  },
+
+  agent(event: string, props: Record<string, unknown>): void {
+    track({ event: `agent.${event}`, properties: props });
+  },
+
+  compaction(event: string, props: Record<string, unknown>): void {
+    track({ event: `compaction.${event}`, properties: props });
+  },
 };

package/src/tests/http-api-integration.test.ts

@@ -1187,6 +1187,10 @@ describe("Repos", () => {
     expect(status).toBe(201);
     expect(body.id).toBeDefined();
     expect(body.name).toBe("test-repo");
+    expect(body.clonePath).toBe("/workspace/personal/repos/test-repo");
+    expect(body.defaultBranch).toBe("main");
+    expect(body.autoClone).toBe(true);
+    expect(body.hooks).toEqual({ enabled: true });
     ids.repo = body.id;
   });
 

package/src/tests/model-control.test.ts

@@ -12,17 +12,17 @@ import {
   updateScheduledTask,
   upsertSwarmConfig,
 } from "../be/db";
-import {
-  parseModelTier,
-  resolveModelTier,
-  resolveTaskModelSelection,
-  splitLegacyModelAlias,
-} from "../model-tiers";
 import { runScheduleNow } from "../scheduler";
 import { createScheduleInputSchema } from "../tools/schedules/create-schedule";
 import { updateScheduleInputSchema } from "../tools/schedules/update-schedule";
 import { sendTaskInputSchema } from "../tools/send-task";
 import { taskActionInputSchema } from "../tools/task-action";
+import {
+  parseModelTier,
+  resolveModelTier,
+  resolveTaskModelSelection,
+  splitLegacyModelAlias,
+} from "../types";
 
 const TEST_DB_PATH = "./test-model-control.sqlite";
 

package/src/tests/swarm-repos.test.ts

@@ -47,9 +47,10 @@ describe("Swarm Repos", () => {
       expect(repo.id).toBeDefined();
       expect(repo.url).toBe("https://github.com/desplega-ai/agent-swarm");
       expect(repo.name).toBe("agent-swarm");
-      expect(repo.clonePath).toBe("/workspace/repos/agent-swarm");
+      expect(repo.clonePath).toBe("/workspace/personal/repos/agent-swarm");
       expect(repo.defaultBranch).toBe("main");
       expect(repo.autoClone).toBe(true);
+      expect(repo.hooks).toEqual({ enabled: true });
       expect(repo.createdAt).toBeDefined();
       expect(repo.lastUpdatedAt).toBeDefined();
     });
@@ -61,11 +62,23 @@ describe("Swarm Repos", () => {
         clonePath: "/workspace/custom/other",
         defaultBranch: "develop",
         autoClone: false,
+        hooks: { enabled: true },
       });
 
       expect(repo.clonePath).toBe("/workspace/custom/other");
       expect(repo.defaultBranch).toBe("develop");
       expect(repo.autoClone).toBe(false);
+      expect(repo.hooks).toEqual({ enabled: true });
+    });
+
+    test("should create a repo with explicitly disabled hooks", () => {
+      const repo = createSwarmRepo({
+        url: "https://github.com/desplega-ai/disabled-hooks-repo",
+        name: "disabled-hooks-repo",
+        hooks: { enabled: false },
+      });
+
+      expect(repo.hooks).toEqual({ enabled: false });
     });
 
     test("should list repos", () => {
@@ -122,14 +135,24 @@ describe("Swarm Repos", () => {
       const updated = updateSwarmRepo(repo!.id, {
         defaultBranch: "develop",
         autoClone: false,
+        hooks: { enabled: true },
       });
 
       expect(updated).not.toBeNull();
       expect(updated?.defaultBranch).toBe("develop");
       expect(updated?.autoClone).toBe(false);
+      expect(updated?.hooks).toEqual({ enabled: true });
       expect(updated?.lastUpdatedAt).not.toBe(repo?.lastUpdatedAt);
     });
 
+    test("should disable hooks by clearing hooks config", () => {
+      const repo = getSwarmRepoByName("agent-swarm");
+      expect(repo?.hooks).toEqual({ enabled: true });
+
+      const updated = updateSwarmRepo(repo!.id, { hooks: null });
+      expect(updated?.hooks).toEqual({ enabled: false });
+    });
+
     test("should update repo name and clonePath", () => {
       const repo = createSwarmRepo({
         url: "https://github.com/desplega-ai/temp-repo",
@@ -265,7 +288,7 @@ describe("Swarm Repos", () => {
         createSwarmRepo({
           url: "https://github.com/desplega-ai/unique-url-2",
           name: "unique-name",
-          clonePath: "/workspace/repos/agent-swarm",
+          clonePath: "/workspace/personal/repos/agent-swarm",
         }),
       ).toThrow();
     });

package/src/tests/task-lifecycle-events.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { emitTaskStarted, onTaskStarted } from "../be/task-lifecycle-events";
+import type { AgentTask } from "../types";
+
+function makeTask(overrides: Partial<AgentTask> = {}): AgentTask {
+  return {
+    id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+    agentId: "11111111-2222-3333-4444-555555555555",
+    task: "Test task",
+    status: "in_progress",
+    source: "github",
+    priority: 50,
+    tags: [],
+    dependsOn: [],
+    wasPaused: false,
+    createdAt: new Date().toISOString(),
+    lastUpdatedAt: new Date().toISOString(),
+    ...overrides,
+  } as AgentTask;
+}
+
+describe("task-lifecycle-events", () => {
+  test("emitTaskStarted invokes a registered onTaskStarted handler with the task", () => {
+    const received: AgentTask[] = [];
+    onTaskStarted((task) => {
+      received.push(task);
+    });
+
+    const task = makeTask();
+    emitTaskStarted(task);
+
+    expect(received).toContain(task);
+  });
+
+  test("a throwing handler does not break emit and later handlers still run", () => {
+    let laterRan = false;
+    onTaskStarted(() => {
+      throw new Error("boom");
+    });
+    onTaskStarted(() => {
+      laterRan = true;
+    });
+
+    expect(() => emitTaskStarted(makeTask())).not.toThrow();
+    expect(laterRan).toBe(true);
+  });
+
+  test("a promise-rejecting handler is fire-and-forget and does not throw", () => {
+    onTaskStarted(() => Promise.reject(new Error("async boom")));
+
+    expect(() => emitTaskStarted(makeTask())).not.toThrow();
+  });
+});

package/src/tests/task-lifecycle-telemetry.test.ts

@@ -9,6 +9,7 @@ import {
   failTask,
   getDb,
   initDb,
+  updateTaskClaudeSessionId,
 } from "../be/db";
 import { telemetry } from "../telemetry";
 
@@ -69,7 +70,6 @@ describe("task lifecycle telemetry", () => {
         props: {
           taskId: task.id,
           source: "mcp",
-          tags: ["telemetry"],
           hasParent: false,
           priority: 60,
         },
@@ -150,4 +150,40 @@ describe("task lifecycle telemetry", () => {
     });
     expect(typeof calls[0]?.props.durationMs).toBe("number");
   });
+
+  test("emits structured task provider and harness context instead of tags", async () => {
+    const task = createTaskExtended("complete telemetry with harness context", {
+      agentId: WORKER_ID,
+      source: "mcp",
+      tags: ["telemetry"],
+    });
+    updateTaskClaudeSessionId(
+      task.id,
+      "provider-session-1",
+      "codex",
+      undefined,
+      "gpt-5.5",
+      "stock",
+      { version: "0.40.1" },
+    );
+    await flushMicrotasks();
+    calls = [];
+
+    completeTask(task.id, "done");
+    await flushMicrotasks();
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toMatchObject({
+      event: "completed",
+      props: {
+        taskId: task.id,
+        source: "mcp",
+        agentId: WORKER_ID,
+        provider: "codex",
+        harnessVariant: "stock",
+        harnessVersion: "0.40.1",
+      },
+    });
+    expect(calls[0]?.props.tags).toBeUndefined();
+  });
 });

package/src/tests/telemetry-init.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import pkg from "../../package.json";
 import {
   _getInstallationIdForTests,
   _isE2bSandbox,
@@ -478,6 +479,37 @@ describe("initTelemetry", () => {
     });
   });
 
+  describe("track() ships swarmVersion in properties", () => {
+    const originalFetch = globalThis.fetch;
+    let captured: Record<string, unknown> | null = null;
+
+    beforeEach(() => {
+      captured = null;
+      globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+        captured = init?.body ? JSON.parse(init.body) : null;
+        return new Response(null, { status: 204 });
+      }) as typeof fetch;
+    });
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    test("includes the package version on every event and ignores caller overrides", async () => {
+      await initTelemetry(
+        "worker",
+        async () => "install_version_test",
+        async () => {},
+      );
+
+      track({ event: "test.event", properties: { swarmVersion: "spoofed" } });
+      await new Promise((r) => setTimeout(r, 0));
+
+      const properties = (captured as { properties: Record<string, unknown> }).properties;
+      expect(properties.swarmVersion).toBe(pkg.version);
+    });
+  });
+
   describe("track() metadata.environment", () => {
     const originalFetch = globalThis.fetch;
     const originalNodeEnv = process.env.NODE_ENV;

package/src/tools/prompt-templates/preview.ts

@@ -2,7 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getTemplateDefinition } from "@/prompts/registry";
 import { createToolRegistrar } from "@/tools/utils";
-import { interpolate } from "@/workflows/template";
+import { interpolate } from "@/utils/template";
 
 export const registerPreviewPromptTemplateTool = (server: McpServer) => {
   createToolRegistrar(server)(

package/src/tools/repos/update-repo.ts

@@ -2,7 +2,7 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { updateSwarmRepo } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
-import { RepoGuidelinesSchema, SwarmRepoSchema } from "@/types";
+import { RepoGuidelinesSchema, RepoHooksSchema, SwarmRepoSchema } from "@/types";
 
 export const registerUpdateRepoTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -20,6 +20,11 @@ export const registerUpdateRepoTool = (server: McpServer) => {
         clonePath: z.string().optional().describe("New clone path."),
         defaultBranch: z.string().optional().describe("New default branch."),
         autoClone: z.boolean().optional().describe("Whether to auto-clone."),
+        hooks: RepoHooksSchema.nullable()
+          .optional()
+          .describe(
+            "Repository hook install config. Set { enabled: true } to opt into best-effort worker hook installation, or null to disable.",
+          ),
         guidelines: RepoGuidelinesSchema.nullable()
           .optional()
           .describe(

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

@@ -5,7 +5,7 @@ import { resolveTaskAuditUserId } from "@/be/audit-user";
 import { createScheduledTask, getAgentById, getScheduledTaskByName } from "@/be/db";
 import { calculateNextRun } from "@/scheduler";
 import { createToolRegistrar } from "@/tools/utils";
-import { ModelTierSchema, splitLegacyModelAlias } from "../../model-tiers";
+import { ModelTierSchema, splitLegacyModelAlias } from "../../types";
 
 export const createScheduleInputSchema = z.object({
   name: z.string().min(1).max(100).describe("Unique name for the schedule (e.g., 'daily-cleanup')"),

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

@@ -11,7 +11,7 @@ import {
 import { mergeScheduleTiming, validateRecurringTiming } from "@/be/schedules/validate";
 import { calculateNextRun } from "@/scheduler";
 import { createToolRegistrar } from "@/tools/utils";
-import { ModelTierSchema, splitLegacyModelAlias } from "../../model-tiers";
+import { ModelTierSchema, splitLegacyModelAlias } from "../../types";
 
 export const updateScheduleInputSchema = z.object({
   scheduleId: z.string().uuid().optional().describe("Schedule ID to update"),

package/src/tools/send-task.ts

@@ -15,8 +15,13 @@ import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
-import { type AgentTask, AgentTaskSchema, FollowUpConfigSchema } from "@/types";
-import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
+import {
+  type AgentTask,
+  AgentTaskSchema,
+  FollowUpConfigSchema,
+  ModelTierSchema,
+  splitLegacyModelAlias,
+} from "@/types";
 
 export const sendTaskInputSchema = z.object({
   agentId: z

package/src/tools/task-action.ts

@@ -27,8 +27,12 @@ import {
 } from "@/be/db";
 import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
-import { AgentTaskSchema, BudgetRefusalCauseSchema } from "@/types";
-import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
+import {
+  AgentTaskSchema,
+  BudgetRefusalCauseSchema,
+  ModelTierSchema,
+  splitLegacyModelAlias,
+} from "@/types";
 
 export const TaskActionSchema = z.enum([
   "create",