stagent 0.1.0 → 0.1.2

package/src/lib/agents/profiles/__tests__/compatibility.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import {
+  getProfileRuntimeCompatibility,
+  getSupportedRuntimes,
+  profileSupportsRuntime,
+  resolveProfileRuntimePayload,
+} from "../compatibility";
+
+const baseProfile = {
+  id: "general",
+  name: "General",
+  skillMd: "# Shared instructions",
+  supportedRuntimes: ["claude-code", "openai-codex-app-server"] as const,
+  allowedTools: ["Read"],
+  tests: [
+    {
+      task: "Summarize the task",
+      expectedKeywords: ["summary"],
+    },
+  ],
+};
+
+describe("profile compatibility helpers", () => {
+  it("defaults missing runtime coverage to Claude Code", () => {
+    expect(getSupportedRuntimes({})).toEqual(["claude-code"]);
+  });
+
+  it("reports supported runtimes explicitly", () => {
+    expect(getSupportedRuntimes(baseProfile)).toEqual([
+      "claude-code",
+      "openai-codex-app-server",
+    ]);
+  });
+
+  it("detects unsupported runtime assignments", () => {
+    expect(
+      profileSupportsRuntime(
+        { ...baseProfile, supportedRuntimes: ["claude-code"] },
+        "openai-codex-app-server"
+      )
+    ).toBe(false);
+  });
+
+  it("resolves runtime-specific instruction overrides", () => {
+    const payload = resolveProfileRuntimePayload(
+      {
+        ...baseProfile,
+        runtimeOverrides: {
+          "openai-codex-app-server": {
+            instructions: "# Codex instructions",
+            allowedTools: ["Read", "Bash"],
+          },
+        },
+      },
+      "openai-codex-app-server"
+    );
+
+    expect(payload.supported).toBe(true);
+    expect(payload.instructions).toBe("# Codex instructions");
+    expect(payload.instructionsSource).toBe("runtime-override");
+    expect(payload.allowedTools).toEqual(["Read", "Bash"]);
+  });
+
+  it("returns an unsupported compatibility summary when runtime is blocked", () => {
+    const compatibility = getProfileRuntimeCompatibility(
+      {
+        ...baseProfile,
+        supportedRuntimes: ["claude-code"],
+      },
+      "openai-codex-app-server"
+    );
+
+    expect(compatibility.supported).toBe(false);
+    expect(compatibility.reason).toContain("does not support");
+  });
+});

package/src/lib/agents/profiles/__tests__/registry.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import yaml from "js-yaml";
+
+// We test the registry by mocking fs to avoid touching the real filesystem.
+// The module under test uses import.meta.dirname so we mock that via the
+// builtins directory path.
+
+const MOCK_SKILLS_DIR = path.join(
+  process.env.HOME ?? ".",
+  ".claude",
+  "skills"
+);
+
+describe("profile registry", () => {
+  // We need to dynamically import registry after mocking
+  let getProfile: typeof import("../registry").getProfile;
+  let listProfiles: typeof import("../registry").listProfiles;
+  let getProfileTags: typeof import("../registry").getProfileTags;
+  let reloadProfiles: typeof import("../registry").reloadProfiles;
+  let isBuiltin: typeof import("../registry").isBuiltin;
+
+  beforeEach(async () => {
+    // Reset module cache so each test gets a fresh registry
+    vi.resetModules();
+    const mod = await import("../registry");
+    getProfile = mod.getProfile;
+    listProfiles = mod.listProfiles;
+    getProfileTags = mod.getProfileTags;
+    reloadProfiles = mod.reloadProfiles;
+    isBuiltin = mod.isBuiltin;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("loads builtin profiles from .claude/skills/", () => {
+    // The registry should find profiles copied by ensureBuiltins
+    const profiles = listProfiles();
+    expect(profiles.length).toBeGreaterThanOrEqual(1);
+
+    // Verify the general profile exists (it's always a builtin)
+    const general = getProfile("general");
+    expect(general).toBeDefined();
+    expect(general!.name).toBe("General");
+    expect(general!.domain).toBe("work");
+  });
+
+  it("returns all 14 builtin profiles", () => {
+    const profiles = listProfiles().filter((p) => isBuiltin(p.id));
+    const ids = profiles.map((p) => p.id);
+
+    expect(ids).toContain("general");
+    expect(ids).toContain("code-reviewer");
+    expect(ids).toContain("researcher");
+    expect(ids).toContain("document-writer");
+    expect(ids).toContain("project-manager");
+    expect(ids).toContain("data-analyst");
+    expect(ids).toContain("wealth-manager");
+    expect(ids).toContain("travel-planner");
+    expect(ids).toContain("technical-writer");
+    expect(ids).toContain("devops-engineer");
+    expect(ids).toContain("health-fitness-coach");
+    expect(ids).toContain("shopping-assistant");
+    expect(ids).toContain("learning-coach");
+    expect(ids).toContain("sweep");
+    expect(profiles.length).toBe(14);
+  });
+
+  it("getProfile returns undefined for unknown id", () => {
+    expect(getProfile("nonexistent")).toBeUndefined();
+  });
+
+  it("profiles have skillMd content from SKILL.md", () => {
+    const codeReviewer = getProfile("code-reviewer");
+    expect(codeReviewer).toBeDefined();
+    expect(codeReviewer!.skillMd).toContain("code reviewer");
+    expect(codeReviewer!.skillMd.length).toBeGreaterThan(50);
+  });
+
+  it("profiles have canUseToolPolicy from profile.yaml", () => {
+    const codeReviewer = getProfile("code-reviewer");
+    expect(codeReviewer?.canUseToolPolicy).toBeDefined();
+    expect(codeReviewer!.canUseToolPolicy!.autoApprove).toContain("Read");
+    expect(codeReviewer!.canUseToolPolicy!.autoApprove).toContain("Grep");
+  });
+
+  it("getProfileTags returns tag map", () => {
+    const tagMap = getProfileTags();
+    expect(tagMap.get("researcher")).toContain("research");
+    expect(tagMap.get("wealth-manager")).toContain("finance");
+  });
+
+  it("systemPrompt is set to skillMd for backward compat", () => {
+    const general = getProfile("general");
+    expect(general).toBeDefined();
+    expect(general!.systemPrompt).toBe(general!.skillMd);
+  });
+
+  it("reloadProfiles clears cache and re-scans", () => {
+    const before = listProfiles().length;
+    reloadProfiles();
+    const after = listProfiles().length;
+    // After reload, should still find the same profiles
+    expect(after).toBe(before);
+  });
+
+  it("profiles extract description from SKILL.md frontmatter", () => {
+    const researcher = getProfile("researcher");
+    expect(researcher).toBeDefined();
+    expect(researcher!.description).toContain("research");
+  });
+
+  it("profiles have correct domain values", () => {
+    const builtinProfiles = listProfiles().filter((p) => isBuiltin(p.id));
+    const workProfiles = builtinProfiles.filter((p) => p.domain === "work");
+    const personalProfiles = builtinProfiles.filter(
+      (p) => p.domain === "personal"
+    );
+
+    expect(workProfiles.length).toBe(9); // general, code-reviewer, researcher, document-writer, project-manager, data-analyst, technical-writer, devops-engineer, sweep
+    expect(personalProfiles.length).toBe(5); // wealth-manager, travel-planner, health-fitness-coach, shopping-assistant, learning-coach
+  });
+
+  it("detects a newly added on-disk profile after the cache is warm", async () => {
+    const originalHome = process.env.HOME;
+    const tempHome = fs.mkdtempSync(
+      path.join(os.tmpdir(), "registry-cache-regression-")
+    );
+
+    try {
+      process.env.HOME = tempHome;
+      vi.resetModules();
+
+      const registry = await import("../registry");
+      const warmProfiles = registry.listProfiles();
+      const initialCount = warmProfiles.length;
+      const profileId = `registry-cache-regression-${Date.now()}`;
+      const profileDir = path.join(tempHome, ".claude", "skills", profileId);
+
+      fs.mkdirSync(profileDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(profileDir, "profile.yaml"),
+        yaml.dump({
+          id: profileId,
+          name: "Registry Cache Regression",
+          version: "1.0.0",
+          domain: "work",
+          tags: ["regression", "cache"],
+        })
+      );
+      fs.writeFileSync(
+        path.join(profileDir, "SKILL.md"),
+        `---
+name: ${profileId}
+description: Profile added after the registry cache is warm.
+---
+
+This profile exists to verify automatic cache refresh for on-disk changes.
+`
+      );
+
+      const loaded = registry.getProfile(profileId);
+
+      expect(loaded).toBeDefined();
+      expect(loaded?.name).toBe("Registry Cache Regression");
+      expect(registry.listProfiles().length).toBe(initialCount + 1);
+    } finally {
+      process.env.HOME = originalHome;
+      fs.rmSync(tempHome, { recursive: true, force: true });
+      vi.resetModules();
+    }
+  });
+});

package/src/lib/agents/profiles/builtins/sweep/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: sweep
+description: Proactive project sweep agent that audits the codebase for improvement opportunities
+---
+
+# Sweep Agent
+
+You are a project sweep agent. Your role is to systematically audit the project and identify improvement opportunities.
+
+## What to Analyze
+
+1. **Code Quality**: Look for code smells, duplicated logic, overly complex functions, and opportunities for simplification
+2. **Test Coverage Gaps**: Identify important code paths that lack test coverage
+3. **Documentation Drift**: Find outdated comments, missing JSDoc, or docs that no longer match the code
+4. **Dependency Health**: Check for outdated dependencies, unused imports, or security advisories
+5. **Performance**: Spot potential performance issues like N+1 queries, unnecessary re-renders, or missing indexes
+6. **Consistency**: Find inconsistencies in naming conventions, patterns, or architectural approaches
+
+## Output Format
+
+You MUST output a valid JSON array of improvement task proposals. Each entry should follow this schema:
+
+```json
+[
+  {
+    "title": "Short descriptive title of the improvement",
+    "description": "Detailed description of what needs to be done and why",
+    "priority": 1,
+    "suggestedProfile": "general"
+  }
+]
+```
+
+### Fields
+
+- `title`: Concise task title (imperative voice, e.g., "Refactor payment module to reduce duplication")
+- `description`: 2-4 sentences explaining the issue, its impact, and the suggested approach
+- `priority`: 1 (critical) to 4 (nice-to-have)
+- `suggestedProfile`: Which agent profile should handle this task (e.g., "general", "code-reviewer", "document-writer")
+
+## Guidelines
+
+- Focus on actionable, specific improvements — not vague suggestions
+- Prioritize issues that affect reliability, security, or developer productivity
+- Limit output to the 10 most impactful improvements
+- Do not suggest improvements that are already tracked or in progress
+- Each improvement should be independently completable as a single task

package/src/lib/agents/profiles/builtins/sweep/profile.yaml

@@ -0,0 +1,12 @@
+id: sweep
+name: Sweep
+version: "1.0.0"
+domain: work
+tags: [sweep, audit, improvement, maintenance]
+supportedRuntimes: [claude-code]
+
+temperature: 0.3
+maxTurns: 50
+outputFormat: json
+
+author: stagent

package/src/lib/agents/runtime/__tests__/catalog.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import {
+  DEFAULT_AGENT_RUNTIME,
+  getRuntimeCapabilities,
+  getRuntimeCatalogEntry,
+  listRuntimeCatalog,
+  resolveAgentRuntime,
+} from "@/lib/agents/runtime/catalog";
+
+describe("runtime catalog", () => {
+  it("defaults to the Claude runtime", () => {
+    expect(resolveAgentRuntime()).toBe(DEFAULT_AGENT_RUNTIME);
+  });
+
+  it("returns runtime metadata and capabilities", () => {
+    const runtime = getRuntimeCatalogEntry("claude-code");
+    const capabilities = getRuntimeCapabilities("claude-code");
+
+    expect(runtime.label).toBe("Claude Code");
+    expect(capabilities.resume).toBe(true);
+    expect(capabilities.profileTests).toBe(true);
+  });
+
+  it("lists the OpenAI Codex runtime", () => {
+    const runtimes = listRuntimeCatalog();
+
+    expect(runtimes.some((runtime) => runtime.id === "openai-codex-app-server")).toBe(
+      true
+    );
+    expect(getRuntimeCapabilities("openai-codex-app-server").resume).toBe(true);
+  });
+
+  it("throws for unknown runtime ids", () => {
+    expect(() => resolveAgentRuntime("unknown-runtime")).toThrow(
+      "Unknown agent type: unknown-runtime"
+    );
+  });
+});

package/src/lib/agents/runtime/openai-codex.ts

@@ -591,7 +591,7 @@ async function initializeOpenAIClient(
   await client.request("initialize", {
     clientInfo: {
       name: "Stagent",
-      version: "0.1.0",
+      version: "0.1.1",
     },
     capabilities: null,
   });

package/src/lib/agents/sweep.ts

@@ -0,0 +1,65 @@
+import { db } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+
+interface SweepProposal {
+  title: string;
+  description: string;
+  priority: number;
+  suggestedProfile?: string;
+}
+
+/**
+ * Process the result of a sweep task — parse the JSON output and create
+ * improvement tasks in the database.
+ */
+export async function processSweepResult(taskId: string): Promise<void> {
+  const [task] = await db
+    .select({ result: tasks.result, projectId: tasks.projectId })
+    .from(tasks)
+    .where(eq(tasks.id, taskId));
+
+  if (!task?.result) return;
+
+  // Try to extract JSON array from the result
+  let proposals: SweepProposal[];
+  try {
+    // The result might have surrounding text — try to find JSON array
+    const jsonMatch = task.result.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return;
+    proposals = JSON.parse(jsonMatch[0]);
+  } catch {
+    console.error("[sweep] Failed to parse sweep result as JSON");
+    return;
+  }
+
+  if (!Array.isArray(proposals) || proposals.length === 0) return;
+
+  // Create improvement tasks
+  const now = new Date();
+  const values = proposals
+    .filter(
+      (p) =>
+        p && typeof p.title === "string" && typeof p.description === "string"
+    )
+    .slice(0, 10) // Cap at 10 tasks
+    .map((proposal) => ({
+      id: crypto.randomUUID(),
+      projectId: task.projectId,
+      title: proposal.title.slice(0, 200),
+      description: `[Sweep-generated] ${proposal.description}`,
+      status: "planned" as const,
+      priority: Math.min(Math.max(proposal.priority ?? 3, 1), 4),
+      agentProfile: proposal.suggestedProfile ?? "general",
+      resumeCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    }));
+
+  if (values.length > 0) {
+    await db.insert(tasks).values(values);
+    console.log(
+      `[sweep] Created ${values.length} improvement tasks from sweep ${taskId}`
+    );
+  }
+}

package/src/lib/constants/__tests__/task-status.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import {
+  TASK_STATUSES,
+  COLUMN_ORDER,
+  VALID_TRANSITIONS,
+  USER_DRAG_TRANSITIONS,
+  isValidTransition,
+  isValidDragTransition,
+} from "@/lib/constants/task-status";
+import type { TaskStatus } from "@/lib/constants/task-status";
+
+describe("TASK_STATUSES", () => {
+  it("contains all 6 statuses", () => {
+    expect(TASK_STATUSES).toHaveLength(6);
+    expect(TASK_STATUSES).toContain("planned");
+    expect(TASK_STATUSES).toContain("queued");
+    expect(TASK_STATUSES).toContain("running");
+    expect(TASK_STATUSES).toContain("completed");
+    expect(TASK_STATUSES).toContain("failed");
+    expect(TASK_STATUSES).toContain("cancelled");
+  });
+});
+
+describe("COLUMN_ORDER", () => {
+  it("excludes cancelled from visible columns", () => {
+    expect(COLUMN_ORDER).not.toContain("cancelled");
+  });
+
+  it("has 5 columns in display order", () => {
+    expect(COLUMN_ORDER).toEqual(["planned", "queued", "running", "completed", "failed"]);
+  });
+});
+
+describe("VALID_TRANSITIONS", () => {
+  it("defines transitions for every status", () => {
+    for (const status of TASK_STATUSES) {
+      expect(VALID_TRANSITIONS[status]).toBeDefined();
+      expect(Array.isArray(VALID_TRANSITIONS[status])).toBe(true);
+    }
+  });
+
+  it("allows planned → queued and planned → cancelled", () => {
+    expect(VALID_TRANSITIONS.planned).toContain("queued");
+    expect(VALID_TRANSITIONS.planned).toContain("cancelled");
+  });
+
+  it("does not allow running → queued (no backward skip)", () => {
+    expect(VALID_TRANSITIONS.running).not.toContain("queued");
+  });
+
+  it("allows failed → planned (retry path)", () => {
+    expect(VALID_TRANSITIONS.failed).toContain("planned");
+  });
+
+  it("allows failed → queued (direct re-queue)", () => {
+    expect(VALID_TRANSITIONS.failed).toContain("queued");
+  });
+
+  it("allows failed → running (resume path)", () => {
+    expect(VALID_TRANSITIONS.failed).toContain("running");
+  });
+
+  it("allows cancelled → running (resume path)", () => {
+    expect(VALID_TRANSITIONS.cancelled).toContain("running");
+  });
+});
+
+describe("isValidTransition", () => {
+  it("returns true for valid transitions", () => {
+    expect(isValidTransition("planned", "queued")).toBe(true);
+    expect(isValidTransition("queued", "running")).toBe(true);
+    expect(isValidTransition("running", "completed")).toBe(true);
+    expect(isValidTransition("running", "failed")).toBe(true);
+  });
+
+  it("returns true for resume transitions", () => {
+    expect(isValidTransition("failed", "running")).toBe(true);
+    expect(isValidTransition("cancelled", "running")).toBe(true);
+  });
+
+  it("returns false for invalid transitions", () => {
+    expect(isValidTransition("planned", "completed")).toBe(false);
+    expect(isValidTransition("completed", "running")).toBe(false);
+    expect(isValidTransition("running", "queued")).toBe(false);
+  });
+
+  it("returns false for same-status transitions", () => {
+    for (const status of TASK_STATUSES) {
+      expect(isValidTransition(status, status)).toBe(false);
+    }
+  });
+});
+
+describe("isValidDragTransition", () => {
+  it("allows planned ↔ queued drag", () => {
+    expect(isValidDragTransition("planned", "queued")).toBe(true);
+    expect(isValidDragTransition("queued", "planned")).toBe(true);
+  });
+
+  it("prevents dragging from running", () => {
+    expect(USER_DRAG_TRANSITIONS.running).toEqual([]);
+    for (const target of TASK_STATUSES) {
+      expect(isValidDragTransition("running", target)).toBe(false);
+    }
+  });
+
+  it("allows completed → planned (reset)", () => {
+    expect(isValidDragTransition("completed", "planned")).toBe(true);
+  });
+
+  it("allows failed → planned (retry via drag)", () => {
+    expect(isValidDragTransition("failed", "planned")).toBe(true);
+  });
+
+  it("prevents dragging to non-adjacent columns", () => {
+    expect(isValidDragTransition("planned", "running")).toBe(false);
+    expect(isValidDragTransition("planned", "completed")).toBe(false);
+  });
+});

package/src/lib/data/seed-data/__tests__/profiles.test.ts

@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { AgentProfile } from "@/lib/agents/profiles/types";
+
+const {
+  createProfile,
+  updateProfile,
+  deleteProfile,
+  getProfile,
+  isBuiltin,
+} = vi.hoisted(() => ({
+  createProfile: vi.fn(),
+  updateProfile: vi.fn(),
+  deleteProfile: vi.fn(),
+  getProfile: vi.fn(),
+  isBuiltin: vi.fn(),
+}));
+
+vi.mock("@/lib/agents/profiles/registry", () => ({
+  createProfile,
+  updateProfile,
+  deleteProfile,
+  getProfile,
+  isBuiltin,
+}));
+
+import {
+  SAMPLE_PROFILE_IDS,
+  clearSampleProfiles,
+  getSampleProfiles,
+  upsertSampleProfiles,
+} from "../profiles";
+import { createSchedules } from "../schedules";
+
+describe("sample profile seeds", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    getProfile.mockReturnValue(undefined);
+    isBuiltin.mockReturnValue(false);
+  });
+
+  it("defines stable reserved sample profile ids", () => {
+    expect(SAMPLE_PROFILE_IDS).toHaveLength(3);
+    expect(SAMPLE_PROFILE_IDS.every((id) => id.startsWith("stagent-sample-"))).toBe(true);
+  });
+
+  it("returns realistic sample profiles with skill markdown", () => {
+    const profiles = getSampleProfiles();
+
+    expect(profiles).toHaveLength(3);
+    expect(profiles.map((profile) => profile.config.id)).toEqual(
+      Array.from(SAMPLE_PROFILE_IDS)
+    );
+    expect(profiles[0].skillMd).toContain("description:");
+    expect(profiles[1].config.tags).toContain("messaging");
+    expect(profiles[2].config.domain).toBe("personal");
+  });
+
+  it("creates missing sample profiles", () => {
+    const count = upsertSampleProfiles();
+
+    expect(count).toBe(3);
+    expect(createProfile).toHaveBeenCalledTimes(3);
+    expect(updateProfile).not.toHaveBeenCalled();
+  });
+
+  it("updates existing custom sample profiles", () => {
+    const existingProfile = { id: SAMPLE_PROFILE_IDS[0] } as AgentProfile;
+    getProfile.mockImplementation((id: string) =>
+      id === SAMPLE_PROFILE_IDS[0] ? existingProfile : undefined
+    );
+
+    const count = upsertSampleProfiles();
+
+    expect(count).toBe(3);
+    expect(updateProfile).toHaveBeenCalledTimes(1);
+    expect(updateProfile).toHaveBeenCalledWith(
+      SAMPLE_PROFILE_IDS[0],
+      expect.objectContaining({ id: SAMPLE_PROFILE_IDS[0] }),
+      expect.stringContaining("Revenue Operations Analyst")
+    );
+    expect(createProfile).toHaveBeenCalledTimes(2);
+  });
+
+  it("throws if a sample id collides with a built-in profile", () => {
+    getProfile.mockReturnValue({ id: SAMPLE_PROFILE_IDS[0] } as AgentProfile);
+    isBuiltin.mockImplementation((id: string) => id === SAMPLE_PROFILE_IDS[0]);
+
+    expect(() => upsertSampleProfiles()).toThrow(/collides with a built-in profile/);
+    expect(updateProfile).not.toHaveBeenCalled();
+    expect(createProfile).not.toHaveBeenCalled();
+  });
+
+  it("deletes only existing non-builtin sample profiles", () => {
+    getProfile.mockImplementation((id: string) =>
+      id === SAMPLE_PROFILE_IDS[0] || id === SAMPLE_PROFILE_IDS[2]
+        ? ({ id } as AgentProfile)
+        : undefined
+    );
+    isBuiltin.mockImplementation((id: string) => id === SAMPLE_PROFILE_IDS[2]);
+
+    const deleted = clearSampleProfiles();
+
+    expect(deleted).toBe(1);
+    expect(deleteProfile).toHaveBeenCalledTimes(1);
+    expect(deleteProfile).toHaveBeenCalledWith(SAMPLE_PROFILE_IDS[0]);
+  });
+});
+
+describe("schedule seeds", () => {
+  it("creates schedules tied to seeded projects and profile surfaces", () => {
+    const projectIds = [
+      "project-investments",
+      "project-launch",
+      "project-pipeline",
+      "project-trip",
+      "project-tax",
+    ];
+
+    const schedules = createSchedules(projectIds);
+
+    expect(schedules).toHaveLength(4);
+    expect(schedules.map((schedule) => schedule.projectId)).toEqual([
+      projectIds[0],
+      projectIds[1],
+      projectIds[2],
+      projectIds[4],
+    ]);
+    expect(
+      schedules.filter((schedule) => schedule.status === "active").every(
+        (schedule) => schedule.nextFireAt instanceof Date
+      )
+    ).toBe(true);
+    expect(
+      schedules.filter((schedule) => schedule.status !== "active").every(
+        (schedule) => schedule.nextFireAt === null
+      )
+    ).toBe(true);
+    expect(schedules.some((schedule) => schedule.agentProfile === SAMPLE_PROFILE_IDS[0])).toBe(true);
+    expect(schedules.some((schedule) => schedule.agentProfile === "project-manager")).toBe(true);
+  });
+});