stagent 0.9.5 → 0.10.0

package/src/lib/schedules/__tests__/slot-claim.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { tasks, schedules, projects, settings } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { claimSlot, countRunningScheduledSlots } from "../slot-claim";
+import { reapExpiredLeases } from "../slot-claim";
+
+function seedProject(): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(projects)
+    .values({ id, name: "test", status: "active", createdAt: now, updatedAt: now })
+    .run();
+  return id;
+}
+
+function seedSchedule(projectId: string): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(schedules)
+    .values({
+      id,
+      projectId,
+      name: `sched-${id.slice(0, 4)}`,
+      prompt: "test",
+      cronExpression: "* * * * *",
+      status: "active",
+      type: "scheduled",
+      firingCount: 0,
+      suppressionCount: 0,
+      heartbeatSpentToday: 0,
+      failureStreak: 0,
+      turnBudgetBreachStreak: 0,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+function seedQueuedTask(scheduleId: string): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(tasks)
+    .values({
+      id,
+      scheduleId,
+      title: "test firing",
+      status: "queued",
+      priority: 2,
+      sourceType: "scheduled",
+      resumeCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+describe("claimSlot", () => {
+  beforeEach(() => {
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+    db.delete(settings).where(eq(settings.key, "schedule.maxConcurrent")).run();
+  });
+
+  it("claims a slot when capacity available, transitioning queued→running", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    const result = claimSlot(tid, 2, 1200);
+
+    expect(result.claimed).toBe(true);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.status).toBe("running");
+    expect(row?.slotClaimedAt).not.toBeNull();
+    expect(row?.leaseExpiresAt).not.toBeNull();
+  });
+
+  it("refuses to claim when cap=0", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    const result = claimSlot(tid, 0, 1200);
+
+    expect(result.claimed).toBe(false);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.status).toBe("queued");
+  });
+
+  it("refuses when cap already full", () => {
+    const pid = seedProject();
+    const sid1 = seedSchedule(pid);
+    const sid2 = seedSchedule(pid);
+    const tid1 = seedQueuedTask(sid1);
+    const tid2 = seedQueuedTask(sid2);
+
+    expect(claimSlot(tid1, 1, 1200).claimed).toBe(true);
+    expect(claimSlot(tid2, 1, 1200).claimed).toBe(false);
+
+    const row2 = db.select().from(tasks).where(eq(tasks.id, tid2)).get();
+    expect(row2?.status).toBe("queued");
+  });
+
+  it("two concurrent claim attempts for the same task yield exactly one winner", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    const first = claimSlot(tid, 10, 1200);
+    const second = claimSlot(tid, 10, 1200);
+
+    expect(first.claimed).toBe(true);
+    expect(second.claimed).toBe(false); // task already running, can't re-claim
+  });
+
+  it("respects cap across multiple tasks from different schedules", () => {
+    const pid = seedProject();
+    const tids: string[] = [];
+    for (let i = 0; i < 5; i++) {
+      const sid = seedSchedule(pid);
+      tids.push(seedQueuedTask(sid));
+    }
+
+    // Cap of 3 → first 3 claim, last 2 fail
+    const results = tids.map((tid) => claimSlot(tid, 3, 1200));
+    expect(results.filter((r) => r.claimed).length).toBe(3);
+    expect(results.filter((r) => !r.claimed).length).toBe(2);
+
+    expect(countRunningScheduledSlots()).toBe(3);
+  });
+
+  it("countRunningScheduledSlots ignores non-scheduled tasks", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const schedTid = seedQueuedTask(sid);
+    claimSlot(schedTid, 10, 1200);
+
+    // Insert a manual running task — must not count against scheduled cap
+    const manualId = randomUUID();
+    const now = new Date();
+    db.insert(tasks)
+      .values({
+        id: manualId,
+        title: "manual",
+        status: "running",
+        priority: 2,
+        sourceType: "manual",
+        resumeCount: 0,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    expect(countRunningScheduledSlots()).toBe(1);
+  });
+
+  it("writes leaseExpiresAt = slotClaimedAt + leaseSec", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    const before = Date.now();
+    claimSlot(tid, 10, 60);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+
+    expect(row?.slotClaimedAt?.getTime()).toBeGreaterThanOrEqual(before);
+    expect(
+      row!.leaseExpiresAt!.getTime() - row!.slotClaimedAt!.getTime(),
+    ).toBe(60 * 1000);
+  });
+});
+
+describe("reapExpiredLeases", () => {
+  beforeEach(() => {
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+  });
+
+  it("marks an expired running task as failed with failure_reason=lease_expired", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    // Claim with a 1-second lease, then fast-forward via direct DB edit
+    claimSlot(tid, 10, 1);
+    const past = new Date(Date.now() - 5000);
+    db.update(tasks)
+      .set({ leaseExpiresAt: past })
+      .where(eq(tasks.id, tid))
+      .run();
+
+    const reaped = reapExpiredLeases();
+
+    expect(reaped).toEqual([tid]);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.status).toBe("failed");
+    expect(row?.failureReason).toBe("lease_expired");
+  });
+
+  it("leaves fresh running tasks alone", () => {
+    const pid = seedProject();
+    const sid = seedSchedule(pid);
+    const tid = seedQueuedTask(sid);
+
+    claimSlot(tid, 10, 3600); // 1-hour lease
+
+    const reaped = reapExpiredLeases();
+
+    expect(reaped).toEqual([]);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.status).toBe("running");
+  });
+
+  it("reaps multiple expired tasks in one sweep", () => {
+    const pid = seedProject();
+    const tids: string[] = [];
+    for (let i = 0; i < 3; i++) {
+      const sid = seedSchedule(pid);
+      const tid = seedQueuedTask(sid);
+      claimSlot(tid, 10, 1);
+      tids.push(tid);
+    }
+    const past = new Date(Date.now() - 5000);
+    for (const tid of tids) {
+      db.update(tasks)
+        .set({ leaseExpiresAt: past })
+        .where(eq(tasks.id, tid))
+        .run();
+    }
+
+    const reaped = reapExpiredLeases();
+
+    expect(reaped.sort()).toEqual([...tids].sort());
+    expect(countRunningScheduledSlots()).toBe(0);
+  });
+});

package/src/lib/schedules/__tests__/tick-scheduler.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { db } from "@/lib/db";
+import { tasks, schedules, projects, settings, scheduleFiringMetrics } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { tickScheduler } from "../scheduler";
+import { registerChatStream, unregisterChatStream } from "@/lib/chat/active-streams";
+
+// Stub the runtime — we're testing coordination, not the SDK
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: vi.fn().mockResolvedValue(undefined),
+}));
+
+function seedProject(): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(projects)
+    .values({ id, name: "test", status: "active", createdAt: now, updatedAt: now })
+    .run();
+  return id;
+}
+
+function seedScheduleDue(projectId: string, nextFireAt: Date): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(schedules)
+    .values({
+      id,
+      projectId,
+      name: `sched-${id.slice(0, 4)}`,
+      prompt: "test prompt",
+      cronExpression: "* * * * *",
+      status: "active",
+      type: "scheduled",
+      firingCount: 0,
+      suppressionCount: 0,
+      heartbeatSpentToday: 0,
+      failureStreak: 0,
+      turnBudgetBreachStreak: 0,
+      nextFireAt,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+describe("tickScheduler with concurrency cap", () => {
+  beforeEach(() => {
+    db.delete(scheduleFiringMetrics).run();
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+    db.delete(settings).where(eq(settings.key, "schedule.maxConcurrent")).run();
+    db.insert(settings)
+      .values({ key: "schedule.maxConcurrent", value: "2", updatedAt: new Date() })
+      .run();
+    for (const id of ["x", "y", "z"]) unregisterChatStream(id);
+  });
+
+  it("fires up to cap schedules, queues the rest", async () => {
+    const pid = seedProject();
+    const past = new Date(Date.now() - 10_000);
+    for (let i = 0; i < 5; i++) seedScheduleDue(pid, past);
+
+    await tickScheduler();
+
+    const runningCount = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.status, "running"))
+      .all().length;
+    const queuedCount = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.status, "queued"))
+      .all().length;
+
+    expect(runningCount).toBe(2); // cap=2
+    expect(queuedCount).toBe(3); // remaining 3 waiting
+  });
+
+  it("defers new firings when chat is active", async () => {
+    const pid = seedProject();
+    const past = new Date(Date.now() - 10_000);
+    const sid = seedScheduleDue(pid, past);
+
+    registerChatStream("x");
+
+    await tickScheduler();
+
+    // No task should have been created
+    const taskCount = db.select().from(tasks).all().length;
+    expect(taskCount).toBe(0);
+
+    // The schedule's next_fire_at should have been pushed forward ≥25s
+    const row = db.select().from(schedules).where(eq(schedules.id, sid)).get();
+    expect(row?.nextFireAt?.getTime()).toBeGreaterThan(Date.now() + 25 * 1000);
+
+    unregisterChatStream("x");
+  });
+});

package/src/lib/schedules/__tests__/turn-budget.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { db } from "@/lib/db";
+import { tasks, schedules, projects, settings, scheduleFiringMetrics } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { tickScheduler, recordFiringMetrics } from "../scheduler";
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: vi.fn().mockResolvedValue(undefined),
+}));
+
+describe("per-schedule turn budget propagation", () => {
+  beforeEach(() => {
+    db.delete(scheduleFiringMetrics).run();
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+    db.delete(settings).where(eq(settings.key, "schedule.maxConcurrent")).run();
+    db.insert(settings)
+      .values({ key: "schedule.maxConcurrent", value: "10", updatedAt: new Date() })
+      .run();
+  });
+
+  it("copies schedules.max_turns into tasks.max_turns at firing time", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "bounded",
+        prompt: "test",
+        cronExpression: "* * * * *",
+        status: "active",
+        type: "scheduled",
+        firingCount: 0,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 0,
+        nextFireAt: new Date(now.getTime() - 10_000),
+        maxTurns: 42,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    await tickScheduler();
+
+    const [task] = db.select().from(tasks).where(eq(tasks.scheduleId, sid)).all();
+    expect(task?.maxTurns).toBe(42);
+  });
+
+  it("leaves tasks.max_turns null when schedules.max_turns is null", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "unbounded",
+        prompt: "test",
+        cronExpression: "* * * * *",
+        status: "active",
+        type: "scheduled",
+        firingCount: 0,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 0,
+        nextFireAt: new Date(now.getTime() - 10_000),
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    await tickScheduler();
+
+    const [task] = db.select().from(tasks).where(eq(tasks.scheduleId, sid)).all();
+    expect(task?.maxTurns).toBeNull();
+  });
+});
+
+async function seedBreachedTask(scheduleId: string): Promise<string> {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(tasks)
+    .values({
+      id,
+      scheduleId,
+      title: "firing",
+      status: "failed",
+      result: "Agent exhausted its turn limit (42 turns used)",
+      priority: 2,
+      sourceType: "scheduled",
+      resumeCount: 0,
+      failureReason: "turn_limit_exceeded",
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+describe("turn_budget_breach_streak", () => {
+  beforeEach(() => {
+    db.delete(scheduleFiringMetrics).run();
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+  });
+
+  it("does NOT increment generic failureStreak on turn-budget breach", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "bounded",
+        prompt: "test",
+        cronExpression: "* * * * *",
+        status: "active",
+        type: "scheduled",
+        firingCount: 1,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 0,
+        maxTurns: 20,
+        maxTurnsSetAt: new Date(now.getTime() - 86400_000), // yesterday
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    const tid = await seedBreachedTask(sid);
+    await recordFiringMetrics(sid, tid);
+
+    const row = db.select().from(schedules).where(eq(schedules.id, sid)).get();
+    expect(row?.failureStreak).toBe(0);
+    expect(row?.turnBudgetBreachStreak).toBe(1);
+  });
+
+  it("applies first-breach grace when maxTurns was set recently", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "bounded",
+        prompt: "test",
+        cronExpression: "0 * * * *", // hourly
+        status: "active",
+        type: "scheduled",
+        firingCount: 1,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 0,
+        maxTurns: 20,
+        // maxTurnsSetAt 30 min ago → first firing after edit → grace applies
+        maxTurnsSetAt: new Date(now.getTime() - 30 * 60 * 1000),
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    const tid = await seedBreachedTask(sid);
+    await recordFiringMetrics(sid, tid);
+
+    const row = db.select().from(schedules).where(eq(schedules.id, sid)).get();
+    expect(row?.turnBudgetBreachStreak).toBe(0); // grace applied
+  });
+
+  it("auto-pauses at turn_budget_breach_streak >= 5", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "bounded",
+        prompt: "test",
+        cronExpression: "* * * * *",
+        status: "active",
+        type: "scheduled",
+        firingCount: 5,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 4, // next breach trips the threshold
+        maxTurns: 20,
+        maxTurnsSetAt: new Date(now.getTime() - 86400_000),
+        createdAt: now,
+        updatedAt: now,
+      })
+      .run();
+
+    const tid = await seedBreachedTask(sid);
+    await recordFiringMetrics(sid, tid);
+
+    const row = db.select().from(schedules).where(eq(schedules.id, sid)).get();
+    expect(row?.status).toBe("paused");
+    expect(row?.turnBudgetBreachStreak).toBe(5);
+  });
+});

package/src/lib/schedules/collision-check.ts

@@ -0,0 +1,105 @@
+import { db } from "@/lib/db";
+import { schedules } from "@/lib/db/schema";
+import { and, eq, ne } from "drizzle-orm";
+import { expandCronMinutes } from "./interval-parser";
+
+const BUCKET_SIZE_MIN = 5;
+const COLLISION_THRESHOLD_TURNS = 3000;
+
+export interface CronCollisionWarning {
+  type: "cron_collision";
+  overlappingSchedules: string[];
+  overlappingMinutes: number[];
+  estimatedConcurrentSteps: number;
+}
+
+/**
+ * Check if a candidate cron collides with existing active schedules in the
+ * same project inside a 5-minute bucket, weighted by the sum of their
+ * avgTurnsPerFiring. Warns only when combined weight exceeds 3000 steps.
+ *
+ * Passing an excludeScheduleId skips that schedule (for PATCH/PUT flows where a
+ * schedule should not collide with its own prior state).
+ *
+ * Deterministic — runs against nominal cron expansion, not chat-pressure
+ * adjusted times.
+ */
+export function checkCollision(
+  candidateCron: string,
+  candidateAvgTurns: number,
+  projectId: string | null,
+  excludeScheduleId: string | null,
+): CronCollisionWarning[] {
+  let candidateMinutes: number[];
+  try {
+    candidateMinutes = expandCronMinutes(candidateCron);
+  } catch {
+    return [];
+  }
+
+  const candidateBuckets = new Set(
+    candidateMinutes.map((m) => Math.floor(m / BUCKET_SIZE_MIN)),
+  );
+
+  const conditions = [eq(schedules.status, "active")];
+  if (projectId !== null) {
+    conditions.push(eq(schedules.projectId, projectId));
+  }
+  if (excludeScheduleId !== null) {
+    conditions.push(ne(schedules.id, excludeScheduleId));
+  }
+
+  const others = db
+    .select({
+      id: schedules.id,
+      name: schedules.name,
+      cronExpression: schedules.cronExpression,
+      avgTurnsPerFiring: schedules.avgTurnsPerFiring,
+    })
+    .from(schedules)
+    .where(and(...conditions))
+    .all();
+
+  const overlappingNames: string[] = [];
+  const overlappingMinutesSet = new Set<number>();
+  let totalOtherTurns = 0;
+
+  for (const other of others) {
+    let otherMinutes: number[];
+    try {
+      otherMinutes = expandCronMinutes(other.cronExpression);
+    } catch {
+      continue;
+    }
+    const otherBuckets = new Set(
+      otherMinutes.map((m) => Math.floor(m / BUCKET_SIZE_MIN)),
+    );
+    const sharedBuckets = [...otherBuckets].filter((b) =>
+      candidateBuckets.has(b),
+    );
+    if (sharedBuckets.length > 0) {
+      overlappingNames.push(other.name);
+      totalOtherTurns += other.avgTurnsPerFiring ?? 0;
+      for (const b of sharedBuckets) {
+        overlappingMinutesSet.add(b * BUCKET_SIZE_MIN);
+      }
+    }
+  }
+
+  const combinedTurns = candidateAvgTurns + totalOtherTurns;
+  if (
+    overlappingNames.length === 0 ||
+    combinedTurns < COLLISION_THRESHOLD_TURNS
+  ) {
+    return [];
+  }
+
+  return [
+    {
+      type: "cron_collision",
+      overlappingSchedules: overlappingNames,
+      overlappingMinutes: [...overlappingMinutesSet].sort((a, b) => a - b),
+      estimatedConcurrentSteps: combinedTurns,
+    },
+  ];
+}