@vellumai/assistant 0.4.42 → 0.4.44

package/src/config/schemas/memory-retrieval.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+
+export const MemoryRerankingConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "memory.retrieval.reranking.enabled must be a boolean" })
+    .default(false),
+  modelIntent: z
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error:
+        "memory.retrieval.reranking.modelIntent must be a valid model intent",
+    })
+    .default("latency-optimized"),
+  topK: z
+    .number({ error: "memory.retrieval.reranking.topK must be a number" })
+    .int("memory.retrieval.reranking.topK must be an integer")
+    .positive("memory.retrieval.reranking.topK must be a positive integer")
+    .default(20),
+});
+
+export const MemoryDynamicBudgetConfigSchema = z.object({
+  enabled: z
+    .boolean({
+      error: "memory.retrieval.dynamicBudget.enabled must be a boolean",
+    })
+    .default(true),
+  minInjectTokens: z
+    .number({
+      error: "memory.retrieval.dynamicBudget.minInjectTokens must be a number",
+    })
+    .int("memory.retrieval.dynamicBudget.minInjectTokens must be an integer")
+    .positive(
+      "memory.retrieval.dynamicBudget.minInjectTokens must be a positive integer",
+    )
+    .default(1200),
+  maxInjectTokens: z
+    .number({
+      error: "memory.retrieval.dynamicBudget.maxInjectTokens must be a number",
+    })
+    .int("memory.retrieval.dynamicBudget.maxInjectTokens must be an integer")
+    .positive(
+      "memory.retrieval.dynamicBudget.maxInjectTokens must be a positive integer",
+    )
+    .default(10000),
+  targetHeadroomTokens: z
+    .number({
+      error:
+        "memory.retrieval.dynamicBudget.targetHeadroomTokens must be a number",
+    })
+    .int(
+      "memory.retrieval.dynamicBudget.targetHeadroomTokens must be an integer",
+    )
+    .positive(
+      "memory.retrieval.dynamicBudget.targetHeadroomTokens must be a positive integer",
+    )
+    .default(10000),
+});
+
+export const MemoryEarlyTerminationConfigSchema = z.object({
+  enabled: z
+    .boolean({
+      error: "memory.retrieval.earlyTermination.enabled must be a boolean",
+    })
+    .default(true),
+  minCandidates: z
+    .number({
+      error: "memory.retrieval.earlyTermination.minCandidates must be a number",
+    })
+    .int("memory.retrieval.earlyTermination.minCandidates must be an integer")
+    .positive(
+      "memory.retrieval.earlyTermination.minCandidates must be a positive integer",
+    )
+    .default(20),
+  minHighConfidence: z
+    .number({
+      error:
+        "memory.retrieval.earlyTermination.minHighConfidence must be a number",
+    })
+    .int(
+      "memory.retrieval.earlyTermination.minHighConfidence must be an integer",
+    )
+    .positive(
+      "memory.retrieval.earlyTermination.minHighConfidence must be a positive integer",
+    )
+    .default(10),
+  confidenceThreshold: z
+    .number({
+      error:
+        "memory.retrieval.earlyTermination.confidenceThreshold must be a number",
+    })
+    .min(
+      0,
+      "memory.retrieval.earlyTermination.confidenceThreshold must be >= 0",
+    )
+    .max(
+      1,
+      "memory.retrieval.earlyTermination.confidenceThreshold must be <= 1",
+    )
+    .default(0.7),
+});
+
+/**
+ * Per-kind freshness windows (in days). Items older than their window
+ * (based on lastSeenAt) are down-ranked unless recently reinforced.
+ * A value of 0 disables freshness decay for that kind.
+ */
+const MemoryFreshnessConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "memory.retrieval.freshness.enabled must be a boolean" })
+    .default(true),
+  maxAgeDays: z
+    .object({
+      fact: z
+        .number({
+          error: "memory.retrieval.freshness.maxAgeDays.fact must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.fact must be non-negative",
+        )
+        .default(0),
+      preference: z
+        .number({
+          error:
+            "memory.retrieval.freshness.maxAgeDays.preference must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.preference must be non-negative",
+        )
+        .default(0),
+      behavior: z
+        .number({
+          error:
+            "memory.retrieval.freshness.maxAgeDays.behavior must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.behavior must be non-negative",
+        )
+        .default(90),
+      event: z
+        .number({
+          error: "memory.retrieval.freshness.maxAgeDays.event must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.event must be non-negative",
+        )
+        .default(30),
+      opinion: z
+        .number({
+          error:
+            "memory.retrieval.freshness.maxAgeDays.opinion must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.opinion must be non-negative",
+        )
+        .default(60),
+    })
+    .default({ fact: 0, preference: 0, behavior: 90, event: 30, opinion: 60 }),
+  staleDecay: z
+    .number({ error: "memory.retrieval.freshness.staleDecay must be a number" })
+    .min(0, "memory.retrieval.freshness.staleDecay must be >= 0")
+    .max(1, "memory.retrieval.freshness.staleDecay must be <= 1")
+    .default(0.5),
+  reinforcementShieldDays: z
+    .number({
+      error:
+        "memory.retrieval.freshness.reinforcementShieldDays must be a number",
+    })
+    .nonnegative(
+      "memory.retrieval.freshness.reinforcementShieldDays must be non-negative",
+    )
+    .default(7),
+});
+
+export const MemoryRetrievalConfigSchema = z.object({
+  lexicalTopK: z
+    .number({ error: "memory.retrieval.lexicalTopK must be a number" })
+    .int("memory.retrieval.lexicalTopK must be an integer")
+    .positive("memory.retrieval.lexicalTopK must be a positive integer")
+    .default(80),
+  semanticTopK: z
+    .number({ error: "memory.retrieval.semanticTopK must be a number" })
+    .int("memory.retrieval.semanticTopK must be an integer")
+    .positive("memory.retrieval.semanticTopK must be a positive integer")
+    .default(40),
+  maxInjectTokens: z
+    .number({ error: "memory.retrieval.maxInjectTokens must be a number" })
+    .int("memory.retrieval.maxInjectTokens must be an integer")
+    .positive("memory.retrieval.maxInjectTokens must be a positive integer")
+    .default(10000),
+  injectionFormat: z
+    .enum(["markdown", "structured_v1"], {
+      error:
+        'memory.retrieval.injectionFormat must be "markdown" or "structured_v1"',
+    })
+    .default("markdown"),
+  injectionStrategy: z
+    .enum(["prepend_user_block", "separate_context_message"], {
+      error:
+        'memory.retrieval.injectionStrategy must be "prepend_user_block" or "separate_context_message"',
+    })
+    .default("prepend_user_block"),
+  reranking: MemoryRerankingConfigSchema.default(
+    MemoryRerankingConfigSchema.parse({}),
+  ),
+  freshness: MemoryFreshnessConfigSchema.default(
+    MemoryFreshnessConfigSchema.parse({}),
+  ),
+  scopePolicy: z
+    .enum(["allow_global_fallback", "strict"], {
+      error:
+        'memory.retrieval.scopePolicy must be "allow_global_fallback" or "strict"',
+    })
+    .default("allow_global_fallback"),
+  dynamicBudget: MemoryDynamicBudgetConfigSchema.default(
+    MemoryDynamicBudgetConfigSchema.parse({}),
+  ),
+  earlyTermination: MemoryEarlyTerminationConfigSchema.default(
+    MemoryEarlyTerminationConfigSchema.parse({}),
+  ),
+});
+
+export type MemoryRerankingConfig = z.infer<typeof MemoryRerankingConfigSchema>;
+export type MemoryRetrievalConfig = z.infer<typeof MemoryRetrievalConfigSchema>;

package/src/config/schemas/memory-storage.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+
+const VALID_MEMORY_EMBEDDING_PROVIDERS = [
+  "auto",
+  "local",
+  "openai",
+  "gemini",
+  "ollama",
+] as const;
+
+const VALID_QDRANT_QUANTIZATION = ["scalar", "none"] as const;
+
+export const MemoryEmbeddingsConfigSchema = z.object({
+  required: z
+    .boolean({ error: "memory.embeddings.required must be a boolean" })
+    .default(true),
+  provider: z
+    .enum(VALID_MEMORY_EMBEDDING_PROVIDERS, {
+      error: `memory.embeddings.provider must be one of: ${VALID_MEMORY_EMBEDDING_PROVIDERS.join(
+        ", ",
+      )}`,
+    })
+    .default("auto"),
+  localModel: z
+    .string({ error: "memory.embeddings.localModel must be a string" })
+    .default("Xenova/bge-small-en-v1.5"),
+  openaiModel: z
+    .string({ error: "memory.embeddings.openaiModel must be a string" })
+    .default("text-embedding-3-small"),
+  geminiModel: z
+    .string({ error: "memory.embeddings.geminiModel must be a string" })
+    .default("gemini-embedding-001"),
+  ollamaModel: z
+    .string({ error: "memory.embeddings.ollamaModel must be a string" })
+    .default("nomic-embed-text"),
+});
+
+export const QdrantConfigSchema = z.object({
+  url: z
+    .string({ error: "memory.qdrant.url must be a string" })
+    .default("http://127.0.0.1:6333"),
+  collection: z
+    .string({ error: "memory.qdrant.collection must be a string" })
+    .default("memory"),
+  vectorSize: z
+    .number({ error: "memory.qdrant.vectorSize must be a number" })
+    .int("memory.qdrant.vectorSize must be an integer")
+    .positive("memory.qdrant.vectorSize must be a positive integer")
+    .default(384),
+  onDisk: z
+    .boolean({ error: "memory.qdrant.onDisk must be a boolean" })
+    .default(true),
+  quantization: z
+    .enum(VALID_QDRANT_QUANTIZATION, {
+      error: `memory.qdrant.quantization must be one of: ${VALID_QDRANT_QUANTIZATION.join(
+        ", ",
+      )}`,
+    })
+    .default("scalar"),
+});
+
+export const MemorySegmentationConfigSchema = z.object({
+  targetTokens: z
+    .number({ error: "memory.segmentation.targetTokens must be a number" })
+    .int("memory.segmentation.targetTokens must be an integer")
+    .positive("memory.segmentation.targetTokens must be a positive integer")
+    .default(450),
+  overlapTokens: z
+    .number({ error: "memory.segmentation.overlapTokens must be a number" })
+    .int("memory.segmentation.overlapTokens must be an integer")
+    .nonnegative(
+      "memory.segmentation.overlapTokens must be a non-negative integer",
+    )
+    .default(60),
+});
+
+export type MemoryEmbeddingsConfig = z.infer<
+  typeof MemoryEmbeddingsConfigSchema
+>;
+export type QdrantConfig = z.infer<typeof QdrantConfigSchema>;
+export type MemorySegmentationConfig = z.infer<
+  typeof MemorySegmentationConfigSchema
+>;

package/src/config/schemas/memory.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+
+import {
+  MemoryCleanupConfigSchema,
+  MemoryJobsConfigSchema,
+  MemoryRetentionConfigSchema,
+} from "./memory-lifecycle.js";
+import {
+  MemoryConflictsConfigSchema,
+  MemoryEntityConfigSchema,
+  MemoryExtractionConfigSchema,
+  MemoryProfileConfigSchema,
+  MemorySummarizationConfigSchema,
+} from "./memory-processing.js";
+import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
+import {
+  MemoryEmbeddingsConfigSchema,
+  MemorySegmentationConfigSchema,
+  QdrantConfigSchema,
+} from "./memory-storage.js";
+
+export const MemoryConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "memory.enabled must be a boolean" })
+    .default(true),
+  embeddings: MemoryEmbeddingsConfigSchema.default(
+    MemoryEmbeddingsConfigSchema.parse({}),
+  ),
+  qdrant: QdrantConfigSchema.default(QdrantConfigSchema.parse({})),
+  retrieval: MemoryRetrievalConfigSchema.default(
+    MemoryRetrievalConfigSchema.parse({}),
+  ),
+  segmentation: MemorySegmentationConfigSchema.default(
+    MemorySegmentationConfigSchema.parse({}),
+  ),
+  jobs: MemoryJobsConfigSchema.default(MemoryJobsConfigSchema.parse({})),
+  retention: MemoryRetentionConfigSchema.default(
+    MemoryRetentionConfigSchema.parse({}),
+  ),
+  cleanup: MemoryCleanupConfigSchema.default(
+    MemoryCleanupConfigSchema.parse({}),
+  ),
+  extraction: MemoryExtractionConfigSchema.default(
+    MemoryExtractionConfigSchema.parse({}),
+  ),
+  summarization: MemorySummarizationConfigSchema.default(
+    MemorySummarizationConfigSchema.parse({}),
+  ),
+  entity: MemoryEntityConfigSchema.default(MemoryEntityConfigSchema.parse({})),
+  conflicts: MemoryConflictsConfigSchema.default(
+    MemoryConflictsConfigSchema.parse({}),
+  ),
+  profile: MemoryProfileConfigSchema.default(
+    MemoryProfileConfigSchema.parse({}),
+  ),
+});
+
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;

package/src/config/schemas/platform.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+export const VALID_AVATAR_STRATEGIES = [
+  "managed_required",
+  "managed_prefer",
+  "local_only",
+] as const;
+
+export const AvatarConfigSchema = z.object({
+  generationStrategy: z
+    .enum(VALID_AVATAR_STRATEGIES, {
+      error: `avatar.generationStrategy must be one of: ${VALID_AVATAR_STRATEGIES.join(", ")}`,
+    })
+    .default("local_only"),
+});
+
+export type AvatarConfig = z.infer<typeof AvatarConfigSchema>;
+
+export const PlatformConfigSchema = z.object({
+  baseUrl: z
+    .string({ error: "platform.baseUrl must be a string" })
+    .refine(
+      (val) => val === "" || /^https?:\/\//i.test(val),
+      "platform.baseUrl must be an absolute URL starting with http:// or https://",
+    )
+    .default(""),
+});
+
+export type PlatformConfig = z.infer<typeof PlatformConfigSchema>;
+
+export const DaemonConfigSchema = z.object({
+  startupSocketWaitMs: z
+    .number({ error: "daemon.startupSocketWaitMs must be a number" })
+    .int("daemon.startupSocketWaitMs must be an integer")
+    .positive("daemon.startupSocketWaitMs must be a positive integer")
+    .default(5000),
+  stopTimeoutMs: z
+    .number({ error: "daemon.stopTimeoutMs must be a number" })
+    .int("daemon.stopTimeoutMs must be an integer")
+    .positive("daemon.stopTimeoutMs must be a positive integer")
+    .default(5000),
+  sigkillGracePeriodMs: z
+    .number({ error: "daemon.sigkillGracePeriodMs must be a number" })
+    .int("daemon.sigkillGracePeriodMs must be an integer")
+    .positive("daemon.sigkillGracePeriodMs must be a positive integer")
+    .default(2000),
+  titleGenerationMaxTokens: z
+    .number({ error: "daemon.titleGenerationMaxTokens must be a number" })
+    .int("daemon.titleGenerationMaxTokens must be an integer")
+    .positive("daemon.titleGenerationMaxTokens must be a positive integer")
+    .default(30),
+  standaloneRecording: z
+    .boolean({ error: "daemon.standaloneRecording must be a boolean" })
+    .default(true),
+});
+
+export const UiConfigSchema = z.object({
+  userTimezone: z
+    .string({ error: "ui.userTimezone must be a string" })
+    .optional(),
+});
+
+export type DaemonConfig = z.infer<typeof DaemonConfigSchema>;
+export type UiConfig = z.infer<typeof UiConfigSchema>;

package/src/config/schemas/security.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+const VALID_SECRET_ACTIONS = ["redact", "warn", "block", "prompt"] as const;
+const VALID_PERMISSIONS_MODES = ["strict", "workspace"] as const;
+
+export { VALID_PERMISSIONS_MODES, VALID_SECRET_ACTIONS };
+
+export const CustomSecretPatternSchema = z.object({
+  label: z.string({
+    error: "secretDetection.customPatterns[].label must be a string",
+  }),
+  pattern: z.string({
+    error: "secretDetection.customPatterns[].pattern must be a string",
+  }),
+});
+
+export const SecretDetectionConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "secretDetection.enabled must be a boolean" })
+    .default(true),
+  action: z
+    .enum(VALID_SECRET_ACTIONS, {
+      error: `secretDetection.action must be one of: ${VALID_SECRET_ACTIONS.join(
+        ", ",
+      )}`,
+    })
+    .default("redact"),
+  entropyThreshold: z
+    .number({ error: "secretDetection.entropyThreshold must be a number" })
+    .finite("secretDetection.entropyThreshold must be finite")
+    .positive("secretDetection.entropyThreshold must be a positive number")
+    .default(4.0),
+  allowOneTimeSend: z
+    .boolean({ error: "secretDetection.allowOneTimeSend must be a boolean" })
+    .default(false),
+  blockIngress: z
+    .boolean({ error: "secretDetection.blockIngress must be a boolean" })
+    .default(true),
+  customPatterns: z.array(CustomSecretPatternSchema).optional(),
+});
+
+export const PermissionsConfigSchema = z.object({
+  mode: z
+    .enum(VALID_PERMISSIONS_MODES, {
+      error: `permissions.mode must be one of: ${VALID_PERMISSIONS_MODES.join(
+        ", ",
+      )}`,
+    })
+    .default("workspace"),
+});
+
+export type CustomSecretPattern = z.infer<typeof CustomSecretPatternSchema>;
+export type SecretDetectionConfig = z.infer<typeof SecretDetectionConfigSchema>;
+export type PermissionsConfig = z.infer<typeof PermissionsConfigSchema>;

package/src/config/schemas/swarm.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+export const SwarmConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "swarm.enabled must be a boolean" })
+    .default(true),
+  maxWorkers: z
+    .number({ error: "swarm.maxWorkers must be a number" })
+    .int("swarm.maxWorkers must be an integer")
+    .positive("swarm.maxWorkers must be a positive integer")
+    .max(6, "swarm.maxWorkers must be at most 6")
+    .default(3),
+  maxTasks: z
+    .number({ error: "swarm.maxTasks must be a number" })
+    .int("swarm.maxTasks must be an integer")
+    .positive("swarm.maxTasks must be a positive integer")
+    .max(20, "swarm.maxTasks must be at most 20")
+    .default(8),
+  maxRetriesPerTask: z
+    .number({ error: "swarm.maxRetriesPerTask must be a number" })
+    .int("swarm.maxRetriesPerTask must be an integer")
+    .nonnegative("swarm.maxRetriesPerTask must be a non-negative integer")
+    .max(3, "swarm.maxRetriesPerTask must be at most 3")
+    .default(1),
+  workerTimeoutSec: z
+    .number({ error: "swarm.workerTimeoutSec must be a number" })
+    .int("swarm.workerTimeoutSec must be an integer")
+    .positive("swarm.workerTimeoutSec must be a positive integer")
+    .default(900),
+  roleTimeoutsSec: z
+    .object({
+      router: z.number().int().positive().optional(),
+      researcher: z.number().int().positive().optional(),
+      coder: z.number().int().positive().optional(),
+      reviewer: z.number().int().positive().optional(),
+    })
+    .default({}),
+  plannerModelIntent: z
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error: "swarm.plannerModelIntent must be a valid model intent",
+    })
+    .default("latency-optimized"),
+  synthesizerModelIntent: z
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error: "swarm.synthesizerModelIntent must be a valid model intent",
+    })
+    .default("quality-optimized"),
+});
+
+export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;

package/src/config/schemas/timeouts.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+export const TimeoutConfigSchema = z.object({
+  shellMaxTimeoutSec: z
+    .number({ error: "timeouts.shellMaxTimeoutSec must be a number" })
+    .finite("timeouts.shellMaxTimeoutSec must be finite")
+    .positive("timeouts.shellMaxTimeoutSec must be a positive number")
+    .default(600),
+  shellDefaultTimeoutSec: z
+    .number({ error: "timeouts.shellDefaultTimeoutSec must be a number" })
+    .finite("timeouts.shellDefaultTimeoutSec must be finite")
+    .positive("timeouts.shellDefaultTimeoutSec must be a positive number")
+    .default(120),
+  permissionTimeoutSec: z
+    .number({ error: "timeouts.permissionTimeoutSec must be a number" })
+    .finite("timeouts.permissionTimeoutSec must be finite")
+    .positive("timeouts.permissionTimeoutSec must be a positive number")
+    .default(300),
+  toolExecutionTimeoutSec: z
+    .number({ error: "timeouts.toolExecutionTimeoutSec must be a number" })
+    .finite("timeouts.toolExecutionTimeoutSec must be finite")
+    .positive("timeouts.toolExecutionTimeoutSec must be a positive number")
+    .default(120),
+  providerStreamTimeoutSec: z
+    .number({ error: "timeouts.providerStreamTimeoutSec must be a number" })
+    .finite("timeouts.providerStreamTimeoutSec must be finite")
+    .positive("timeouts.providerStreamTimeoutSec must be a positive number")
+    .default(300),
+});
+
+export const RateLimitConfigSchema = z.object({
+  maxRequestsPerMinute: z
+    .number({ error: "rateLimit.maxRequestsPerMinute must be a number" })
+    .int("rateLimit.maxRequestsPerMinute must be an integer")
+    .nonnegative(
+      "rateLimit.maxRequestsPerMinute must be a non-negative integer",
+    )
+    .default(0),
+  maxTokensPerSession: z
+    .number({ error: "rateLimit.maxTokensPerSession must be a number" })
+    .int("rateLimit.maxTokensPerSession must be an integer")
+    .nonnegative("rateLimit.maxTokensPerSession must be a non-negative integer")
+    .default(0),
+});
+
+export type TimeoutConfig = z.infer<typeof TimeoutConfigSchema>;
+export type RateLimitConfig = z.infer<typeof RateLimitConfigSchema>;

package/src/config/{agent-schema.ts → schemas/workspace-git.ts}

@@ -1,100 +1,5 @@
 import { z } from "zod";
 
-export const HeartbeatConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "heartbeat.enabled must be a boolean" })
-      .default(false),
-    intervalMs: z
-      .number({ error: "heartbeat.intervalMs must be a number" })
-      .int("heartbeat.intervalMs must be an integer")
-      .positive("heartbeat.intervalMs must be a positive integer")
-      .default(3_600_000),
-    activeHoursStart: z
-      .number({ error: "heartbeat.activeHoursStart must be a number" })
-      .int("heartbeat.activeHoursStart must be an integer")
-      .min(0, "heartbeat.activeHoursStart must be >= 0")
-      .max(23, "heartbeat.activeHoursStart must be <= 23")
-      .optional(),
-    activeHoursEnd: z
-      .number({ error: "heartbeat.activeHoursEnd must be a number" })
-      .int("heartbeat.activeHoursEnd must be an integer")
-      .min(0, "heartbeat.activeHoursEnd must be >= 0")
-      .max(23, "heartbeat.activeHoursEnd must be <= 23")
-      .optional(),
-  })
-  .superRefine((config, ctx) => {
-    const hasStart = config.activeHoursStart != null;
-    const hasEnd = config.activeHoursEnd != null;
-    if (hasStart !== hasEnd) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: [hasStart ? "activeHoursEnd" : "activeHoursStart"],
-        message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be omitted",
-      });
-    }
-    if (
-      hasStart &&
-      hasEnd &&
-      config.activeHoursStart === config.activeHoursEnd
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["activeHoursEnd"],
-        message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must not be equal (would create an empty window)",
-      });
-    }
-  });
-
-export const SwarmConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "swarm.enabled must be a boolean" })
-    .default(true),
-  maxWorkers: z
-    .number({ error: "swarm.maxWorkers must be a number" })
-    .int("swarm.maxWorkers must be an integer")
-    .positive("swarm.maxWorkers must be a positive integer")
-    .max(6, "swarm.maxWorkers must be at most 6")
-    .default(3),
-  maxTasks: z
-    .number({ error: "swarm.maxTasks must be a number" })
-    .int("swarm.maxTasks must be an integer")
-    .positive("swarm.maxTasks must be a positive integer")
-    .max(20, "swarm.maxTasks must be at most 20")
-    .default(8),
-  maxRetriesPerTask: z
-    .number({ error: "swarm.maxRetriesPerTask must be a number" })
-    .int("swarm.maxRetriesPerTask must be an integer")
-    .nonnegative("swarm.maxRetriesPerTask must be a non-negative integer")
-    .max(3, "swarm.maxRetriesPerTask must be at most 3")
-    .default(1),
-  workerTimeoutSec: z
-    .number({ error: "swarm.workerTimeoutSec must be a number" })
-    .int("swarm.workerTimeoutSec must be an integer")
-    .positive("swarm.workerTimeoutSec must be a positive integer")
-    .default(900),
-  roleTimeoutsSec: z
-    .object({
-      router: z.number().int().positive().optional(),
-      researcher: z.number().int().positive().optional(),
-      coder: z.number().int().positive().optional(),
-      reviewer: z.number().int().positive().optional(),
-    })
-    .default({}),
-  plannerModelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error: "swarm.plannerModelIntent must be a valid model intent",
-    })
-    .default("latency-optimized"),
-  synthesizerModelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error: "swarm.synthesizerModelIntent must be a valid model intent",
-    })
-    .default("quality-optimized"),
-});
-
 export const WorkspaceGitConfigSchema = z.object({
   turnCommitMaxWaitMs: z
     .number({ error: "workspaceGit.turnCommitMaxWaitMs must be a number" })
@@ -261,6 +166,4 @@ export const WorkspaceGitConfigSchema = z.object({
     }),
 });
 
-export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
-export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;
 export type WorkspaceGitConfig = z.infer<typeof WorkspaceGitConfigSchema>;