@herdctl/core 0.0.1 → 0.0.2

package/src/config/__tests__/schema.test.ts

@@ -1,873 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  FleetConfigSchema,
-  DefaultsSchema,
-  WorkspaceSchema,
-  PermissionsSchema,
-  PermissionModeSchema,
-  WorkSourceSchema,
-  GitHubWorkSourceSchema,
-  GitHubAuthSchema,
-  BaseWorkSourceSchema,
-  DockerSchema,
-  ChatSchema,
-  WebhooksSchema,
-  InstancesSchema,
-  AgentReferenceSchema,
-} from "../schema.js";
-
-describe("FleetConfigSchema", () => {
-  it("parses minimal config", () => {
-    const result = FleetConfigSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.version).toBe(1);
-      expect(result.data.agents).toEqual([]);
-    }
-  });
-
-  it("parses complete config", () => {
-    const config = {
-      version: 1,
-      fleet: { name: "test", description: "test fleet" },
-      defaults: {},
-      workspace: { root: "/tmp" },
-      agents: [{ path: "./test.yaml" }],
-      chat: {},
-      webhooks: {},
-      docker: {},
-    };
-    const result = FleetConfigSchema.safeParse(config);
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects invalid version", () => {
-    const result = FleetConfigSchema.safeParse({ version: "1" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects negative version", () => {
-    const result = FleetConfigSchema.safeParse({ version: -1 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects zero version", () => {
-    const result = FleetConfigSchema.safeParse({ version: 0 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("DefaultsSchema", () => {
-  it("parses empty defaults", () => {
-    const result = DefaultsSchema.safeParse({});
-    expect(result.success).toBe(true);
-  });
-
-  it("parses complete defaults", () => {
-    const defaults = {
-      docker: { enabled: true },
-      permissions: { mode: "acceptEdits" },
-      work_source: { type: "github" },
-      instances: { max_concurrent: 2 },
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.docker?.enabled).toBe(true);
-      expect(result.data.permissions?.mode).toBe("acceptEdits");
-      expect(result.data.work_source?.type).toBe("github");
-      expect(result.data.instances?.max_concurrent).toBe(2);
-    }
-  });
-
-  it("parses extended defaults with session", () => {
-    const defaults = {
-      session: {
-        max_turns: 50,
-        timeout: "30m",
-        model: "claude-sonnet-4-20250514",
-      },
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.session?.max_turns).toBe(50);
-      expect(result.data.session?.timeout).toBe("30m");
-      expect(result.data.session?.model).toBe("claude-sonnet-4-20250514");
-    }
-  });
-
-  it("parses extended defaults with model", () => {
-    const defaults = {
-      model: "claude-opus-4-20250514",
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.model).toBe("claude-opus-4-20250514");
-    }
-  });
-
-  it("parses extended defaults with max_turns", () => {
-    const defaults = {
-      max_turns: 100,
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.max_turns).toBe(100);
-    }
-  });
-
-  it("parses extended defaults with permission_mode", () => {
-    const defaults = {
-      permission_mode: "bypassPermissions",
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.permission_mode).toBe("bypassPermissions");
-    }
-  });
-
-  it("parses complete extended defaults", () => {
-    const defaults = {
-      docker: { enabled: false },
-      permissions: {
-        mode: "acceptEdits",
-        allowed_tools: ["Read", "Write"],
-      },
-      work_source: {
-        type: "github",
-        labels: { ready: "ready" },
-      },
-      instances: { max_concurrent: 3 },
-      session: {
-        max_turns: 50,
-        timeout: "1h",
-      },
-      model: "claude-sonnet-4-20250514",
-      max_turns: 100,
-      permission_mode: "acceptEdits",
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.session?.max_turns).toBe(50);
-      expect(result.data.model).toBe("claude-sonnet-4-20250514");
-      expect(result.data.max_turns).toBe(100);
-      expect(result.data.permission_mode).toBe("acceptEdits");
-    }
-  });
-
-  it("rejects invalid permission_mode", () => {
-    const defaults = {
-      permission_mode: "invalid",
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects negative max_turns", () => {
-    const defaults = {
-      max_turns: -1,
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects zero max_turns", () => {
-    const defaults = {
-      max_turns: 0,
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects non-integer max_turns", () => {
-    const defaults = {
-      max_turns: 1.5,
-    };
-    const result = DefaultsSchema.safeParse(defaults);
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("WorkspaceSchema", () => {
-  it("requires root", () => {
-    const result = WorkspaceSchema.safeParse({});
-    expect(result.success).toBe(false);
-  });
-
-  it("parses with root only", () => {
-    const result = WorkspaceSchema.safeParse({ root: "/tmp/workspace" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.root).toBe("/tmp/workspace");
-      expect(result.data.auto_clone).toBe(true);
-      expect(result.data.clone_depth).toBe(1);
-      expect(result.data.default_branch).toBe("main");
-    }
-  });
-
-  it("parses complete workspace config", () => {
-    const workspace = {
-      root: "~/herdctl-workspace",
-      auto_clone: false,
-      clone_depth: 5,
-      default_branch: "develop",
-    };
-    const result = WorkspaceSchema.safeParse(workspace);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.auto_clone).toBe(false);
-      expect(result.data.clone_depth).toBe(5);
-      expect(result.data.default_branch).toBe("develop");
-    }
-  });
-
-  it("rejects non-integer clone_depth", () => {
-    const result = WorkspaceSchema.safeParse({
-      root: "/tmp",
-      clone_depth: 1.5,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects zero clone_depth", () => {
-    const result = WorkspaceSchema.safeParse({ root: "/tmp", clone_depth: 0 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("PermissionsSchema", () => {
-  it("applies default mode", () => {
-    const result = PermissionsSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.mode).toBe("acceptEdits");
-    }
-  });
-
-  it("parses all fields", () => {
-    const permissions = {
-      mode: "bypassPermissions",
-      allowed_tools: ["Read", "Edit"],
-      denied_tools: ["WebSearch"],
-      bash: {
-        allowed_commands: ["git", "npm"],
-        denied_patterns: ["rm -rf /"],
-      },
-    };
-    const result = PermissionsSchema.safeParse(permissions);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.mode).toBe("bypassPermissions");
-      expect(result.data.allowed_tools).toEqual(["Read", "Edit"]);
-      expect(result.data.denied_tools).toEqual(["WebSearch"]);
-      expect(result.data.bash?.allowed_commands).toEqual(["git", "npm"]);
-    }
-  });
-});
-
-describe("PermissionModeSchema", () => {
-  it("accepts valid modes", () => {
-    const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
-    for (const mode of validModes) {
-      const result = PermissionModeSchema.safeParse(mode);
-      expect(result.success).toBe(true);
-    }
-  });
-
-  it("rejects invalid modes", () => {
-    const result = PermissionModeSchema.safeParse("invalid");
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("WorkSourceSchema", () => {
-  it("requires type", () => {
-    const result = WorkSourceSchema.safeParse({});
-    expect(result.success).toBe(false);
-  });
-
-  it("parses minimal github type (base schema)", () => {
-    const result = WorkSourceSchema.safeParse({ type: "github" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.type).toBe("github");
-    }
-  });
-
-  it("parses with labels (base schema)", () => {
-    const workSource = {
-      type: "github",
-      labels: {
-        ready: "ready",
-        in_progress: "in-progress",
-      },
-      cleanup_in_progress: true,
-    };
-    const result = WorkSourceSchema.safeParse(workSource);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.labels?.ready).toBe("ready");
-      expect(result.data.cleanup_in_progress).toBe(true);
-    }
-  });
-
-  it("rejects invalid type", () => {
-    const result = WorkSourceSchema.safeParse({ type: "jira" });
-    expect(result.success).toBe(false);
-  });
-
-  it("parses full GitHub work source configuration", () => {
-    const workSource = {
-      type: "github",
-      repo: "owner/repo-name",
-      labels: {
-        ready: "ready-for-agent",
-        in_progress: "agent-working",
-      },
-      exclude_labels: ["blocked", "wip"],
-      cleanup_on_failure: true,
-      auth: {
-        token_env: "MY_GITHUB_TOKEN",
-      },
-    };
-    const result = WorkSourceSchema.safeParse(workSource);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.type).toBe("github");
-      expect(result.data).toHaveProperty("repo", "owner/repo-name");
-    }
-  });
-});
-
-describe("GitHubWorkSourceSchema", () => {
-  describe("repo field validation", () => {
-    it("requires repo field", () => {
-      const result = GitHubWorkSourceSchema.safeParse({ type: "github" });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues.some((i) => i.path.includes("repo"))).toBe(
-          true
-        );
-      }
-    });
-
-    it("accepts valid owner/repo format", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "octocat/hello-world",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.repo).toBe("octocat/hello-world");
-      }
-    });
-
-    it("accepts repo with hyphens and underscores", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "my-org/my_repo-name",
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it("accepts repo with dots", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "org.name/repo.name",
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it("accepts repo with numbers", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "org123/repo456",
-      });
-      expect(result.success).toBe(true);
-    });
-
-    it("rejects repo without slash", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "just-repo-name",
-      });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.issues[0].message).toContain("owner/repo");
-      }
-    });
-
-    it("rejects repo with multiple slashes", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo/extra",
-      });
-      expect(result.success).toBe(false);
-    });
-
-    it("rejects empty repo", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "",
-      });
-      expect(result.success).toBe(false);
-    });
-
-    it("rejects repo with spaces", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner name/repo name",
-      });
-      expect(result.success).toBe(false);
-    });
-
-    it("provides clear error message for invalid repo format", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "invalid",
-      });
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        const repoError = result.error.issues.find((i) =>
-          i.path.includes("repo")
-        );
-        expect(repoError?.message).toContain("owner/repo");
-        expect(repoError?.message).toContain("octocat/hello-world");
-      }
-    });
-  });
-
-  describe("labels field", () => {
-    it("applies default labels when not specified", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.labels.ready).toBe("ready");
-        expect(result.data.labels.in_progress).toBe("agent-working");
-      }
-    });
-
-    it("allows custom ready label", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        labels: { ready: "custom-ready" },
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.labels.ready).toBe("custom-ready");
-        expect(result.data.labels.in_progress).toBe("agent-working");
-      }
-    });
-
-    it("allows custom in_progress label", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        labels: { in_progress: "working-on-it" },
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.labels.ready).toBe("ready");
-        expect(result.data.labels.in_progress).toBe("working-on-it");
-      }
-    });
-
-    it("allows both custom labels", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        labels: {
-          ready: "todo",
-          in_progress: "doing",
-        },
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.labels.ready).toBe("todo");
-        expect(result.data.labels.in_progress).toBe("doing");
-      }
-    });
-  });
-
-  describe("exclude_labels field", () => {
-    it("defaults to empty array", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.exclude_labels).toEqual([]);
-      }
-    });
-
-    it("accepts array of strings", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        exclude_labels: ["blocked", "wip", "on-hold"],
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.exclude_labels).toEqual([
-          "blocked",
-          "wip",
-          "on-hold",
-        ]);
-      }
-    });
-
-    it("accepts empty array", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        exclude_labels: [],
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.exclude_labels).toEqual([]);
-      }
-    });
-
-    it("rejects non-string array items", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        exclude_labels: ["valid", 123],
-      });
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("cleanup_on_failure field", () => {
-    it("defaults to true", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.cleanup_on_failure).toBe(true);
-      }
-    });
-
-    it("accepts explicit true", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        cleanup_on_failure: true,
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.cleanup_on_failure).toBe(true);
-      }
-    });
-
-    it("accepts false", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        cleanup_on_failure: false,
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.cleanup_on_failure).toBe(false);
-      }
-    });
-
-    it("rejects non-boolean values", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        cleanup_on_failure: "yes",
-      });
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("auth field", () => {
-    it("defaults auth.token_env to GITHUB_TOKEN", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.auth.token_env).toBe("GITHUB_TOKEN");
-      }
-    });
-
-    it("accepts custom token_env", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        auth: { token_env: "MY_GITHUB_PAT" },
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.auth.token_env).toBe("MY_GITHUB_PAT");
-      }
-    });
-
-    it("accepts empty auth object (uses defaults)", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-        auth: {},
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.auth.token_env).toBe("GITHUB_TOKEN");
-      }
-    });
-  });
-
-  describe("complete configuration", () => {
-    it("parses complete GitHub work source config", () => {
-      const config = {
-        type: "github",
-        repo: "my-org/my-repo",
-        labels: {
-          ready: "ready-for-work",
-          in_progress: "in-progress",
-        },
-        exclude_labels: ["blocked", "wip", "needs-review"],
-        cleanup_on_failure: false,
-        auth: {
-          token_env: "GH_ENTERPRISE_TOKEN",
-        },
-      };
-      const result = GitHubWorkSourceSchema.safeParse(config);
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual({
-          type: "github",
-          repo: "my-org/my-repo",
-          labels: {
-            ready: "ready-for-work",
-            in_progress: "in-progress",
-          },
-          exclude_labels: ["blocked", "wip", "needs-review"],
-          cleanup_on_failure: false,
-          auth: {
-            token_env: "GH_ENTERPRISE_TOKEN",
-          },
-        });
-      }
-    });
-
-    it("applies all defaults for minimal config", () => {
-      const result = GitHubWorkSourceSchema.safeParse({
-        type: "github",
-        repo: "owner/repo",
-      });
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.type).toBe("github");
-        expect(result.data.repo).toBe("owner/repo");
-        expect(result.data.labels.ready).toBe("ready");
-        expect(result.data.labels.in_progress).toBe("agent-working");
-        expect(result.data.exclude_labels).toEqual([]);
-        expect(result.data.cleanup_on_failure).toBe(true);
-        expect(result.data.auth.token_env).toBe("GITHUB_TOKEN");
-      }
-    });
-  });
-});
-
-describe("GitHubAuthSchema", () => {
-  it("applies default token_env", () => {
-    const result = GitHubAuthSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.token_env).toBe("GITHUB_TOKEN");
-    }
-  });
-
-  it("accepts custom token_env", () => {
-    const result = GitHubAuthSchema.safeParse({ token_env: "CUSTOM_TOKEN" });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.token_env).toBe("CUSTOM_TOKEN");
-    }
-  });
-});
-
-describe("BaseWorkSourceSchema", () => {
-  it("parses minimal config", () => {
-    const result = BaseWorkSourceSchema.safeParse({ type: "github" });
-    expect(result.success).toBe(true);
-  });
-
-  it("parses with optional fields", () => {
-    const result = BaseWorkSourceSchema.safeParse({
-      type: "github",
-      labels: { ready: "todo" },
-      cleanup_in_progress: true,
-    });
-    expect(result.success).toBe(true);
-  });
-});
-
-describe("DockerSchema", () => {
-  it("applies default enabled", () => {
-    const result = DockerSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.enabled).toBe(false);
-    }
-  });
-
-  it("parses complete docker config", () => {
-    const docker = {
-      enabled: true,
-      base_image: "herdctl-base:latest",
-    };
-    const result = DockerSchema.safeParse(docker);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.enabled).toBe(true);
-      expect(result.data.base_image).toBe("herdctl-base:latest");
-    }
-  });
-});
-
-describe("ChatSchema", () => {
-  it("parses empty chat", () => {
-    const result = ChatSchema.safeParse({});
-    expect(result.success).toBe(true);
-  });
-
-  it("parses discord config", () => {
-    const chat = {
-      discord: {
-        enabled: true,
-        token_env: "DISCORD_TOKEN",
-      },
-    };
-    const result = ChatSchema.safeParse(chat);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.discord?.enabled).toBe(true);
-      expect(result.data.discord?.token_env).toBe("DISCORD_TOKEN");
-    }
-  });
-
-  it("applies default discord enabled", () => {
-    const result = ChatSchema.safeParse({ discord: {} });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.discord?.enabled).toBe(false);
-    }
-  });
-});
-
-describe("WebhooksSchema", () => {
-  it("applies defaults", () => {
-    const result = WebhooksSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.enabled).toBe(false);
-      expect(result.data.port).toBe(8081);
-    }
-  });
-
-  it("parses complete webhooks config", () => {
-    const webhooks = {
-      enabled: true,
-      port: 9000,
-      secret_env: "WEBHOOK_SECRET",
-    };
-    const result = WebhooksSchema.safeParse(webhooks);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.enabled).toBe(true);
-      expect(result.data.port).toBe(9000);
-      expect(result.data.secret_env).toBe("WEBHOOK_SECRET");
-    }
-  });
-
-  it("rejects negative port", () => {
-    const result = WebhooksSchema.safeParse({ port: -1 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects zero port", () => {
-    const result = WebhooksSchema.safeParse({ port: 0 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects non-integer port", () => {
-    const result = WebhooksSchema.safeParse({ port: 80.5 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("InstancesSchema", () => {
-  it("applies default max_concurrent", () => {
-    const result = InstancesSchema.safeParse({});
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.max_concurrent).toBe(1);
-    }
-  });
-
-  it("parses custom max_concurrent", () => {
-    const result = InstancesSchema.safeParse({ max_concurrent: 5 });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.max_concurrent).toBe(5);
-    }
-  });
-
-  it("rejects negative max_concurrent", () => {
-    const result = InstancesSchema.safeParse({ max_concurrent: -1 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects zero max_concurrent", () => {
-    const result = InstancesSchema.safeParse({ max_concurrent: 0 });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects non-integer max_concurrent", () => {
-    const result = InstancesSchema.safeParse({ max_concurrent: 1.5 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("AgentReferenceSchema", () => {
-  it("requires path", () => {
-    const result = AgentReferenceSchema.safeParse({});
-    expect(result.success).toBe(false);
-  });
-
-  it("parses valid path", () => {
-    const result = AgentReferenceSchema.safeParse({
-      path: "./agents/test.yaml",
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.path).toBe("./agents/test.yaml");
-    }
-  });
-
-  it("parses absolute path", () => {
-    const result = AgentReferenceSchema.safeParse({
-      path: "/etc/herdctl/agent.yaml",
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.path).toBe("/etc/herdctl/agent.yaml");
-    }
-  });
-});