@desplega.ai/agent-swarm 1.102.0 → 1.103.0

package/src/commands/runner.ts

@@ -2,7 +2,6 @@ import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { ensure, initialize } from "@desplega.ai/business-use";
 import type { TemplateResponse } from "../../templates/schema.ts";
-import { resolveTaskModelSelection } from "../model-tiers.ts";
 import {
   type Attributes,
   initOtel,
@@ -34,7 +33,7 @@ import {
   type ProviderSessionConfig,
 } from "../providers/index.ts";
 import { initTelemetry, telemetry } from "../telemetry.ts";
-import type { ProviderName, RepoGuidelines } from "../types.ts";
+import { type ProviderName, type RepoGuidelines, resolveTaskModelSelection } from "../types.ts";
 import { getApiKey } from "../utils/api-key.ts";
 import { computeBudgetBackoffMs } from "../utils/budget-backoff.ts";
 import { getMcpBaseUrl } from "../utils/constants.ts";
@@ -52,9 +51,9 @@ import { resolveHarnessProvider } from "../utils/harness-provider.ts";
 import { prettyPrintLine, prettyPrintStderr } from "../utils/pretty-print.ts";
 import { scrubSecrets } from "../utils/secret-scrubber.ts";
 import { refreshSkillsIfChanged } from "../utils/skills-refresh.ts";
+import { interpolate } from "../utils/template.ts";
 import { detectVcsProvider } from "../vcs/index.ts";
 import { validateJsonSchema } from "../workflows/json-schema-validator.ts";
-import { interpolate } from "../workflows/template.ts";
 import { buildContextPreamble, buildResumeContextPreamble } from "./context-preamble.ts";
 import { awaitCredentials, BootMaxWaitExceededError, EX_CONFIG } from "./credential-wait.ts";
 import {
@@ -131,6 +130,7 @@ async function fetchRepoConfig(
   name: string;
   clonePath: string;
   defaultBranch: string;
+  hooks?: { enabled: boolean } | null;
   guidelines?: RepoGuidelines | null;
 } | null> {
   try {
@@ -145,6 +145,7 @@ async function fetchRepoConfig(
         name: string;
         clonePath: string;
         defaultBranch: string;
+        hooks?: { enabled: boolean } | null;
         guidelines?: RepoGuidelines | null;
       }>;
     };
@@ -235,12 +236,40 @@ async function refreshExistingRepoForTask(
   }
 }
 
+function getInstallRepoHooksScriptPath(): string {
+  const imagePath = "/usr/local/bin/install-repo-hooks.sh";
+  if (existsSync(imagePath)) return imagePath;
+  return `${process.cwd()}/scripts/install-repo-hooks.sh`;
+}
+
+async function installRepoHooksForTask(
+  repoConfig: { name: string; clonePath: string; hooks?: { enabled: boolean } | null },
+  role: string,
+): Promise<void> {
+  if (repoConfig.hooks?.enabled !== true) return;
+
+  try {
+    const scriptPath = getInstallRepoHooksScriptPath();
+    await Bun.$`bash ${scriptPath} ${repoConfig.clonePath} ${repoConfig.name}`;
+    console.log(`[${role}] Installed git hooks for ${repoConfig.name}`);
+  } catch (err) {
+    const errorMsg = scrubSecrets((err as Error).message);
+    console.warn(`[${role}] Could not install git hooks for ${repoConfig.name}: ${errorMsg}`);
+  }
+}
+
 /**
  * Ensure a repo is cloned and up-to-date for a task.
  * Returns { clonePath, claudeMd, warning }.
  */
 export async function ensureRepoForTask(
-  repoConfig: { url: string; name: string; clonePath: string; defaultBranch: string },
+  repoConfig: {
+    url: string;
+    name: string;
+    clonePath: string;
+    defaultBranch: string;
+    hooks?: { enabled: boolean } | null;
+  },
   role: string,
 ): Promise<{
   clonePath: string;
@@ -275,6 +304,8 @@ export async function ensureRepoForTask(
       warning = await refreshExistingRepoForTask({ name, clonePath, defaultBranch }, role);
     }
 
+    await installRepoHooksForTask(repoConfig, role);
+
     const claudeMd = await readClaudeMd(clonePath, role);
     const autoStashes = await listSwarmAutostashes(clonePath, role);
     return { clonePath, claudeMd, warning, autoStashes };
@@ -1484,7 +1515,11 @@ function setupShutdownHandlers(
     }
 
     if (apiConfig) {
-      telemetry.session("ended", { agentId: apiConfig.agentId });
+      telemetry.session("ended", {
+        agentId: apiConfig.agentId,
+        durationMs: state ? Date.now() - state.startedAt : undefined,
+        tasksProcessed: state?.tasksProcessed ?? 0,
+      });
       await closeAgent(apiConfig, role);
     }
     await savePm2State(role);
@@ -1554,12 +1589,18 @@ interface RunningTask {
   hasLocalEnvironment: boolean;
   /** Harness variant captured on session_init (e.g. "bridge" or "stock") */
   harnessVariant?: string;
+  /** Harness metadata captured on session_init (currently includes provider package version) */
+  harnessVariantMeta?: Record<string, unknown>;
+  /** Resolved model used for the provider session, when configured */
+  model?: string;
 }
 
 /** Runner state for tracking concurrent tasks */
 interface RunnerState {
   activeTasks: Map<string, RunningTask>;
   maxConcurrent: number;
+  startedAt: number;
+  tasksProcessed: number;
   /**
    * Effective harness provider for this worker boot session — resolved
    * from `swarm_config` (overlay) > `process.env.HARNESS_PROVIDER` > "claude".
@@ -2542,6 +2583,19 @@ function providerEventAttributes(event: ProviderEvent): Attributes {
   }
 }
 
+function normalizeSessionErrorCategory(category: string | undefined): string {
+  switch (category) {
+    case "rate_limit":
+    case "api_error":
+    case "context_overflow":
+    case "timeout":
+    case "provider_error":
+      return category;
+    default:
+      return "unknown";
+  }
+}
+
 /**
  * Entry shape for the `activeToolSpans` map maintained by `runWithSession`.
  * Exported for unit tests that exercise `implicitCloseActiveToolSpans`.
@@ -2799,6 +2853,9 @@ async function spawnProviderProcess(
   const eventFlushTimer = setInterval(flushEvents, EVENT_FLUSH_INTERVAL_MS);
   const sessionStartTime = Date.now();
   let providerSessionId = session.sessionId;
+  let pendingHarnessVariant: string | undefined;
+  let pendingHarnessVariantMeta: Record<string, unknown> | undefined;
+  let runningTaskForSessionInit: RunningTask | undefined;
   const activeToolSpans = new Map<
     string,
     {
@@ -2823,12 +2880,37 @@ async function spawnProviderProcess(
   // snapshots carry a real `cumulativeOutputTokens` (was 0 until completion).
   let cumulativeProgressOutputTokens = 0;
 
+  function bufferSessionLogLine(content: string) {
+    if (!shouldStream) return;
+    logBuffer.lines.push(content);
+    const shouldFlush =
+      logBuffer.lines.length >= LOG_BUFFER_SIZE ||
+      Date.now() - logBuffer.lastFlush >= LOG_FLUSH_INTERVAL_MS;
+    if (shouldFlush) {
+      flushLogBuffer(logBuffer, {
+        apiUrl: opts.apiUrl,
+        apiKey: opts.apiKey,
+        agentId: opts.agentId,
+        sessionId: opts.runnerSessionId,
+        iteration: opts.iteration,
+        taskId: effectiveTaskId,
+        cli: adapter.name,
+      }).catch(() => {});
+    }
+  }
+
   session.onEvent((event) =>
     withSpanContext(sessionSpan, () => {
       sessionSpan.addEvent(`provider.${event.type}`, providerEventAttributes(event));
       switch (event.type) {
         case "session_init":
           providerSessionId = event.sessionId;
+          pendingHarnessVariant = event.harnessVariant;
+          pendingHarnessVariantMeta = event.harnessVariantMeta;
+          if (runningTaskForSessionInit) {
+            runningTaskForSessionInit.harnessVariant = event.harnessVariant;
+            runningTaskForSessionInit.harnessVariantMeta = event.harnessVariantMeta;
+          }
           sessionSpan.setAttributes({
             "agentswarm.provider.session_id": providerSessionId,
             "agentswarm.provider.name": event.provider,
@@ -3074,6 +3156,11 @@ async function spawnProviderProcess(
         }
         case "compaction": {
           // Always record compaction events (no throttle)
+          telemetry.compaction("triggered", {
+            compactTrigger: event.compactTrigger,
+            preCompactTokens: event.preCompactTokens,
+            contextTotalTokens: event.contextTotalTokens,
+          });
           fetch(`${opts.apiUrl}/api/tasks/${realTaskId}/context`, {
             method: "POST",
             headers: {
@@ -3093,26 +3180,17 @@ async function spawnProviderProcess(
         }
         case "raw_log":
           prettyPrintLine(event.content, opts.role);
-          if (shouldStream) {
-            logBuffer.lines.push(event.content);
-            const shouldFlush =
-              logBuffer.lines.length >= LOG_BUFFER_SIZE ||
-              Date.now() - logBuffer.lastFlush >= LOG_FLUSH_INTERVAL_MS;
-            if (shouldFlush) {
-              flushLogBuffer(logBuffer, {
-                apiUrl: opts.apiUrl,
-                apiKey: opts.apiKey,
-                agentId: opts.agentId,
-                sessionId: opts.runnerSessionId,
-                iteration: opts.iteration,
-                taskId: effectiveTaskId,
-                cli: adapter.name,
-              }).catch(() => {});
-            }
-          }
+          bufferSessionLogLine(event.content);
           break;
         case "raw_stderr":
           prettyPrintStderr(event.content, opts.role);
+          bufferSessionLogLine(
+            JSON.stringify({
+              type: "stderr",
+              content: event.content,
+              timestamp: new Date().toISOString(),
+            }),
+          );
           break;
 
         case "progress": {
@@ -3202,6 +3280,21 @@ async function spawnProviderProcess(
             "gen_ai.usage.output_tokens": result.cost.outputTokens ?? 0,
             "agentswarm.cost.total_usd": result.cost.totalCostUsd ?? 0,
           });
+          telemetry.session("cost", {
+            agentId: opts.agentId,
+            model: result.cost.model,
+            provider: result.cost.provider ?? opts.harnessProvider,
+            inputTokens: result.cost.inputTokens ?? 0,
+            outputTokens: result.cost.outputTokens ?? 0,
+            cacheReadTokens: result.cost.cacheReadTokens,
+            cacheWriteTokens: result.cost.cacheWriteTokens,
+            reasoningOutputTokens: result.cost.reasoningOutputTokens,
+            thinkingTokens: result.cost.thinkingTokens,
+            totalCostUsd: result.cost.totalCostUsd,
+            durationMs: result.cost.durationMs,
+            numTurns: result.cost.numTurns,
+            isError: result.cost.isError,
+          });
           try {
             await saveCostData(
               { ...result.cost, taskId: realTaskId, sessionId: opts.runnerSessionId },
@@ -3303,7 +3396,15 @@ async function spawnProviderProcess(
     // swap that mutates the global RunnerState (review finding 2).
     harnessProvider: opts.harnessProvider,
     hasLocalEnvironment: adapter.traits.hasLocalEnvironment,
+    model: model || undefined,
   };
+  runningTaskForSessionInit = runningTask;
+  if (pendingHarnessVariant !== undefined) {
+    runningTask.harnessVariant = pendingHarnessVariant;
+  }
+  if (pendingHarnessVariantMeta !== undefined) {
+    runningTask.harnessVariantMeta = pendingHarnessVariantMeta;
+  }
 
   // Non-blocking completion tracking
   promise
@@ -3333,6 +3434,10 @@ async function checkCompletedProcesses(
     credentialInfo?: RunningTask["credentialInfo"];
     harnessProvider: ProviderName;
     hasLocalEnvironment: boolean;
+    harnessVariant?: string;
+    harnessVariantMeta?: Record<string, unknown>;
+    model?: string;
+    durationMs: number;
   }> = [];
 
   for (const [taskId, task] of state.activeTasks) {
@@ -3350,6 +3455,10 @@ async function checkCompletedProcesses(
         credentialInfo: task.credentialInfo,
         harnessProvider: task.harnessProvider,
         hasLocalEnvironment: task.hasLocalEnvironment,
+        harnessVariant: task.harnessVariant,
+        harnessVariantMeta: task.harnessVariantMeta,
+        model: task.model,
+        durationMs: Date.now() - task.startTime.getTime(),
       });
     }
   }
@@ -3362,6 +3471,10 @@ async function checkCompletedProcesses(
     workingDir,
     credentialInfo,
     harnessProvider,
+    harnessVariant,
+    harnessVariantMeta,
+    model,
+    durationMs,
   } of completedTasks) {
     state.activeTasks.delete(taskId);
     vcsDetectedTasks.delete(taskId);
@@ -3482,6 +3595,33 @@ async function checkCompletedProcesses(
         bridgeFailureDiagnostics,
       );
 
+      telemetry.taskEvent("session_completed", {
+        taskId,
+        agentId: apiConfig.agentId,
+        provider: result.cost?.provider ?? harnessProvider,
+        model: result.cost?.model ?? model,
+        harnessVariant,
+        harnessVersion:
+          typeof harnessVariantMeta?.version === "string" ||
+          typeof harnessVariantMeta?.version === "number"
+            ? String(harnessVariantMeta.version)
+            : undefined,
+        exitCode: result.exitCode,
+        isError: result.exitCode !== 0,
+        durationMs,
+      });
+      if (result.exitCode !== 0 || result.isError) {
+        telemetry.session("failure", {
+          agentId: apiConfig.agentId,
+          errorCategory: normalizeSessionErrorCategory(result.errorCategory),
+          provider: result.cost?.provider ?? harnessProvider,
+          model: result.cost?.model ?? model,
+          durationMs: result.cost?.durationMs ?? durationMs,
+          wasRateLimited: result.rateLimitResetAt != null,
+        });
+      }
+      state.tasksProcessed += 1;
+
       if (result.exitCode === 0 && credentialInfo) {
         reportKeyClearRateLimit(
           apiConfig.apiUrl,
@@ -3660,6 +3800,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   // Failures (network, API down, malformed value) fall back to env then "claude"
   // so a swarm_config outage cannot wedge boot.
   let bootProvider: ProviderName;
+  let bootModel = process.env.MODEL_OVERRIDE || "";
   // Codex credits-exhausted cooldown is sourced solely from the global swarm_config
   // (key `CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS`). Initialize to the default constant
   // for the case where it is unset, then apply the swarm_config value below; on a
@@ -3669,6 +3810,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   try {
     const bootEnv = await fetchResolvedEnv(apiUrl, apiKey, agentId);
     bootProvider = bootEnv.resolvedProvider;
+    bootModel = (bootEnv.env.MODEL_OVERRIDE as string | undefined) || bootModel;
     bootCooldownMs = resolveCodexCreditsExhaustedCooldownMs(
       bootEnv.env.CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
     );
@@ -3733,7 +3875,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       },
     );
   }
-  telemetry.session("started", { agentId });
+  telemetry.session("started", {
+    agentId,
+    harnessProvider: bootProvider,
+    model: bootModel || undefined,
+    role,
+  });
 
   let capabilities = config.capabilities;
 
@@ -3878,6 +4025,8 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   const state: RunnerState = {
     activeTasks: new Map(),
     maxConcurrent,
+    startedAt: Date.now(),
+    tasksProcessed: 0,
     harnessProvider: bootProvider,
     codexCreditsExhaustedCooldownMs: bootCooldownMs,
   };
@@ -4506,7 +4655,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           const effectiveConfig = repoConfig ?? {
             url: task.vcsRepo,
             name: task.vcsRepo.split("/").pop() || task.vcsRepo,
-            clonePath: `/workspace/repos/${task.vcsRepo.split("/").pop() || task.vcsRepo}`,
+            clonePath: `/workspace/personal/repos/${task.vcsRepo.split("/").pop() || task.vcsRepo}`,
             defaultBranch: "main",
           };
           const repoContext = await ensureRepoForTask(effectiveConfig, role);
@@ -4897,7 +5046,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           const effectiveConfig = repoConfig ?? {
             url: taskVcsRepo,
             name: taskVcsRepo.split("/").pop() || taskVcsRepo,
-            clonePath: `/workspace/repos/${taskVcsRepo.split("/").pop() || taskVcsRepo}`,
+            clonePath: `/workspace/personal/repos/${taskVcsRepo.split("/").pop() || taskVcsRepo}`,
             defaultBranch: "main",
           };
           const repoResult = await ensureRepoForTask(effectiveConfig, role);

package/src/github/task-reactions.ts

@@ -1,3 +1,4 @@
+import { onTaskStarted } from "../be/task-lifecycle-events";
 import type { AgentTask } from "../types";
 import {
   addGraphQLReaction,
@@ -64,3 +65,23 @@ export async function addEyesReactionOnTaskStart(task: AgentTask): Promise<void>
     console.error("[GitHub] Failed to add eyes reaction on task start:", error);
   }
 }
+
+let registered = false;
+
+/**
+ * Subscribe the GitHub eyes-reaction handler to the task-started lifecycle event.
+ *
+ * Call this once at API-server boot (from `createServer`). It is the API-side
+ * inverse of the old `be/db` → `github/task-reactions` import: the data layer now
+ * emits `task-started` and this integration reacts. Idempotent — `createServer`
+ * may run more than once per process, so repeated calls register only once.
+ *
+ * API-server only — never wire this on the worker side.
+ */
+export function registerGithubTaskReactions(): void {
+  if (registered) return;
+  registered = true;
+  onTaskStarted((task) => {
+    addEyesReactionOnTaskStart(task).catch(() => {});
+  });
+}

package/src/hooks/tool-loop-detection.test.ts

@@ -62,6 +62,46 @@ describe("tool-loop-detection", () => {
       expect(result!.reason).toContain("stuck in a loop");
     });
 
+    test("returns critical/blocked at 15 identical fully-specified edits", async () => {
+      let result: Awaited<ReturnType<typeof checkToolLoop>> | undefined;
+      for (let i = 0; i < 15; i++) {
+        result = await checkToolLoop(SESSION_KEY, "Edit", {
+          file_path: "/same.ts",
+          old_string: "before",
+          new_string: "after",
+        });
+      }
+      expect(result!.blocked).toBe(true);
+      expect(result!.severity).toBe("critical");
+      expect(result!.reason).toContain("15 times");
+      expect(result!.reason).toContain("Edit");
+    });
+
+    test("does not block normal codex file_change edits to the same file at 15 calls", async () => {
+      let result: Awaited<ReturnType<typeof checkToolLoop>> | undefined;
+      for (let i = 0; i < 15; i++) {
+        result = await checkToolLoop(SESSION_KEY, "Edit", {
+          changes: [{ path: "src/be/db.ts", kind: "update" }],
+        });
+        expect(result.blocked).toBe(false);
+      }
+      expect(result!.severity).toBe("warning");
+      expect(result!.reason).toContain("15 times");
+    });
+
+    test("still blocks prolonged codex file_change repetition", async () => {
+      let result: Awaited<ReturnType<typeof checkToolLoop>> | undefined;
+      for (let i = 0; i < 24; i++) {
+        result = await checkToolLoop(SESSION_KEY, "Edit", {
+          changes: [{ path: "src/be/db.ts", kind: "update" }],
+        });
+      }
+      expect(result!.blocked).toBe(true);
+      expect(result!.severity).toBe("critical");
+      expect(result!.reason).toContain("24 times");
+      expect(result!.reason).toContain("Edit");
+    });
+
     test("does not trigger for different args on same tool", async () => {
       for (let i = 0; i < 20; i++) {
         const result = await checkToolLoop(SESSION_KEY, "Read", {

package/src/hooks/tool-loop-detection.ts

@@ -22,6 +22,7 @@ const HISTORY_DIR = "/tmp/agent-swarm-tool-history";
 const MAX_HISTORY = 30; // Sliding window size
 const REPEAT_WARNING_THRESHOLD = 8;
 const REPEAT_CRITICAL_THRESHOLD = 15;
+const LOW_CARDINALITY_FILE_CHANGE_CRITICAL_THRESHOLD = 24;
 const PINGPONG_WARNING_THRESHOLD = 6;
 const PINGPONG_CRITICAL_THRESHOLD = 12;
 
@@ -40,6 +41,38 @@ function hashArgs(args: Record<string, unknown>): string {
   return hash.toString(36);
 }
 
+function isCodexFileChangeArgs(toolName: string, toolInput: Record<string, unknown>): boolean {
+  if (toolName !== "Edit" && toolName !== "Write" && toolName !== "Delete") {
+    return false;
+  }
+
+  const topLevelKeys = Object.keys(toolInput);
+  if (topLevelKeys.length !== 1 || topLevelKeys[0] !== "changes") {
+    return false;
+  }
+
+  const changes = toolInput.changes;
+  if (!Array.isArray(changes) || changes.length === 0) {
+    return false;
+  }
+
+  return changes.every((change) => {
+    if (!change || typeof change !== "object" || Array.isArray(change)) {
+      return false;
+    }
+
+    const entry = change as Record<string, unknown>;
+    const keys = Object.keys(entry).sort();
+    return (
+      keys.length === 2 &&
+      keys[0] === "kind" &&
+      keys[1] === "path" &&
+      typeof entry.path === "string" &&
+      (entry.kind === "add" || entry.kind === "update" || entry.kind === "delete")
+    );
+  });
+}
+
 /**
  * Load tool call history for a session.
  */
@@ -92,6 +125,9 @@ export async function checkToolLoop(
 
   // Strategy 1: Same tool + same args repeated
   const key = `${toolName}:${argsHash}`;
+  const repeatCriticalThreshold = isCodexFileChangeArgs(toolName, toolInput)
+    ? LOW_CARDINALITY_FILE_CHANGE_CRITICAL_THRESHOLD
+    : REPEAT_CRITICAL_THRESHOLD;
   let repeatCount = 0;
   for (const record of history) {
     if (`${record.toolName}:${record.argsHash}` === key) {
@@ -99,7 +135,7 @@ export async function checkToolLoop(
     }
   }
 
-  if (repeatCount >= REPEAT_CRITICAL_THRESHOLD) {
+  if (repeatCount >= repeatCriticalThreshold) {
     return {
       blocked: true,
       severity: "critical",

package/src/http/agents.ts

@@ -21,6 +21,7 @@ import {
   updateAgentStatus,
   upsertSwarmConfig,
 } from "../be/db";
+import { telemetry } from "../telemetry";
 import {
   AgentCredStatusSchema,
   AgentLatestModelSchema,
@@ -322,6 +323,12 @@ export async function handleAgentRegister(
       return { agent, created: true };
     })();
 
+    telemetry.agent("registered", {
+      role: parsed.body.role,
+      capabilities: parsed.body.capabilities ?? [],
+      isReconnect: !result.created,
+    });
+
     if (result.created) {
       ensure({
         id: "registered",

package/src/http/index.ts

@@ -22,6 +22,7 @@ import {
   withSpanContext,
 } from "../otel";
 import { startScriptRunSupervisor, stopScriptRunSupervisor } from "../script-workflows/supervisor";
+import { getServerSessionsProcessed } from "../server-runtime-counters";
 import { startSlackApp, stopSlackApp } from "../slack";
 import { initTelemetry, telemetry } from "../telemetry";
 import { getApiKey } from "../utils/api-key";
@@ -113,6 +114,8 @@ const globalState = globalThis as typeof globalThis & {
 
 const API_GC_INTERVAL_MS = 5 * 60 * 1000;
 const MCP_TRANSPORT_IDLE_TIMEOUT_MS = DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS;
+const serverStartedAt = Date.now();
+let shutdownSignal = "unknown";
 
 type GcCapableGlobal = typeof globalThis & { gc?: () => void };
 
@@ -363,6 +366,11 @@ globalState.__transportActivityUser = transportActivityUser;
 
 async function shutdown() {
   console.log("Shutting down HTTP server...");
+  telemetry.server("shutdown", {
+    signal: shutdownSignal,
+    uptimeMs: Date.now() - serverStartedAt,
+    sessionsProcessed: getServerSessionsProcessed(),
+  });
 
   // Stop scheduler (if enabled)
   if (hasCapability("scheduling")) {
@@ -424,8 +432,14 @@ async function shutdown() {
 // Only register signal handlers once (avoid duplicates on hot reload)
 if (!globalState.__sigintRegistered) {
   globalState.__sigintRegistered = true;
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => {
+    shutdownSignal = "SIGINT";
+    shutdown();
+  });
+  process.on("SIGTERM", () => {
+    shutdownSignal = "SIGTERM";
+    shutdown();
+  });
 }
 
 if (!globalState.__runId) {

package/src/http/prompt-templates.ts

@@ -12,7 +12,7 @@ import {
 } from "../be/db";
 import { getAllTemplateDefinitions, getTemplateDefinition } from "../prompts/registry";
 import { resolveTemplate } from "../prompts/resolver";
-import { interpolate } from "../workflows/template";
+import { interpolate } from "../utils/template";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 

package/src/http/repos.ts

@@ -7,7 +7,7 @@ import {
   getSwarmRepos,
   updateSwarmRepo,
 } from "../be/db";
-import { RepoGuidelinesSchema, SwarmRepoSchema } from "../types";
+import { RepoGuidelinesSchema, RepoHooksSchema, SwarmRepoSchema } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -56,6 +56,7 @@ const createRepo = route({
     clonePath: z.string().optional(),
     defaultBranch: z.string().optional(),
     autoClone: z.boolean().optional(),
+    hooks: RepoHooksSchema.optional(),
     guidelines: RepoGuidelinesSchema.nullable().optional(),
   }),
   responses: {
@@ -78,6 +79,7 @@ const updateRepo = route({
     clonePath: z.string().optional(),
     defaultBranch: z.string().optional(),
     autoClone: z.boolean().optional(),
+    hooks: RepoHooksSchema.nullable().optional(),
     guidelines: RepoGuidelinesSchema.nullable().optional(),
   }),
   responses: {
@@ -141,6 +143,7 @@ export async function handleRepos(
         clonePath: parsed.body.clonePath,
         defaultBranch: parsed.body.defaultBranch,
         autoClone: parsed.body.autoClone,
+        hooks: parsed.body.hooks,
         guidelines: parsed.body.guidelines,
       });
       json(res, repo, 201);
@@ -165,6 +168,7 @@ export async function handleRepos(
         clonePath: parsed.body.clonePath,
         defaultBranch: parsed.body.defaultBranch,
         autoClone: parsed.body.autoClone,
+        hooks: parsed.body.hooks,
         guidelines: parsed.body.guidelines,
       });
       if (!updated) {

package/src/http/schedules.ts

@@ -13,8 +13,8 @@ import {
   updateScheduledTask,
 } from "../be/db";
 import { mergeScheduleTiming, validateRecurringTiming } from "../be/schedules/validate";
-import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 import { calculateNextRun, createStandaloneScheduleTask } from "../scheduler/scheduler";
+import { ModelTierSchema, splitLegacyModelAlias } from "../types";
 import { getExecutorRegistry } from "../workflows";
 import { handleScheduleTrigger } from "../workflows/triggers";
 import { route } from "./route-def";

package/src/http/session-data.ts

@@ -14,6 +14,7 @@ import {
   getTaskById,
 } from "../be/db";
 import { normalizeModelKey } from "../be/pricing-normalize";
+import { incrementServerSessionsProcessed } from "../server-runtime-counters";
 import type { SessionCost, SessionCostSource } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
@@ -290,6 +291,7 @@ export async function handleSessionData(
         isError: parsed.body.isError ?? false,
         costSource,
       });
+      incrementServerSessionsProcessed();
       json(res, { success: true, cost }, 201);
     } catch (error) {
       console.error("[HTTP] Failed to create session cost:", error);