@cursor/july 0.1.20 → 0.1.21

package/src/internal/trajectory.subagents.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest";
+import type { SessionEvent } from "../types.js";
+import { buildTrajectory, formatTrajectoryText } from "./trajectory.js";
+
+function ev(
+  partial: Omit<SessionEvent, "index" | "sessionId" | "at"> & {
+    index?: number;
+  }
+): SessionEvent {
+  return {
+    index: partial.index ?? 0,
+    sessionId: "sess_1",
+    at: "2026-01-01T00:00:00.000Z",
+    ...partial,
+  } as SessionEvent;
+}
+
+describe("buildTrajectory subagent progress", () => {
+  it("keeps bare top-level task in toolCalls for calledTool evals", () => {
+    const traj = buildTrajectory([
+      ev({ type: "session.started", data: { channelId: "http" } }),
+      ev({
+        type: "message.received",
+        turnId: "turn_1",
+        data: { text: "review this" },
+      }),
+      ev({
+        type: "actions.requested",
+        turnId: "turn_1",
+        data: {
+          calls: [
+            {
+              callId: "task-1",
+              toolName: "task",
+              args: { description: "deep review" },
+            },
+          ],
+        },
+      }),
+      ev({
+        type: "subagent.called",
+        turnId: "turn_1",
+        data: {
+          callId: "task-1",
+          name: "reviewer",
+          description: "deep review",
+        },
+      }),
+      ev({
+        type: "actions.requested",
+        turnId: "turn_1",
+        data: {
+          parentCallId: "task-1",
+          calls: [
+            {
+              callId: "shell-1",
+              toolName: "shell",
+              args: { command: "ls" },
+              parentCallId: "task-1",
+            },
+          ],
+        },
+      }),
+      ev({
+        type: "action.result",
+        turnId: "turn_1",
+        data: {
+          callId: "shell-1",
+          toolName: "shell",
+          output: "ok",
+          isError: false,
+          parentCallId: "task-1",
+        },
+      }),
+      ev({
+        type: "subagent.completed",
+        turnId: "turn_1",
+        data: { callId: "task-1", name: "reviewer" },
+      }),
+      ev({
+        type: "action.result",
+        turnId: "turn_1",
+        data: {
+          callId: "task-1",
+          toolName: "task",
+          output: { done: true },
+          isError: false,
+        },
+      }),
+      ev({
+        type: "message.completed",
+        turnId: "turn_1",
+        data: { text: "Parent reply.", finishReason: "stop" },
+      }),
+      ev({ type: "turn.completed", turnId: "turn_1", data: {} }),
+    ]);
+
+    const turn = traj.turns[0]!;
+    expect(turn.toolCalls.map((c) => c.toolName)).toContain("task");
+    expect(turn.toolCalls.find((c) => c.toolName === "task")).toMatchObject({
+      callId: "task-1",
+      output: { done: true },
+    });
+    expect(turn.subagents).toHaveLength(1);
+    expect(turn.subagents[0]?.toolCalls.map((c) => c.toolName)).toEqual([
+      "shell",
+    ]);
+    expect(turn.assistantText).toBe("Parent reply.");
+    expect(traj.finalText).toBe("Parent reply.");
+  });
+
+  it("does not let nested message.completed overwrite parent assistantText", () => {
+    const traj = buildTrajectory([
+      ev({
+        type: "message.received",
+        turnId: "turn_1",
+        data: { text: "hi" },
+      }),
+      ev({
+        type: "subagent.called",
+        turnId: "turn_1",
+        data: { callId: "task-1", name: "worker" },
+      }),
+      ev({
+        type: "message.completed",
+        turnId: "turn_1",
+        data: {
+          text: "Nested says hi.",
+          finishReason: "stop",
+          parentCallId: "task-1",
+        },
+      }),
+      ev({
+        type: "message.completed",
+        turnId: "turn_1",
+        data: { text: "Parent final.", finishReason: "stop" },
+      }),
+      ev({ type: "turn.completed", turnId: "turn_1", data: {} }),
+    ]);
+
+    expect(traj.turns[0]?.assistantText).toBe("Parent final.");
+    expect(traj.finalText).toBe("Parent final.");
+  });
+
+  it("does not let nested reasoning.appended overwrite parent reasoningText", () => {
+    const traj = buildTrajectory([
+      ev({
+        type: "reasoning.appended",
+        turnId: "turn_1",
+        data: {
+          delta: "parent think",
+          text: "parent think",
+        },
+      }),
+      ev({
+        type: "reasoning.appended",
+        turnId: "turn_1",
+        data: {
+          delta: "nested think",
+          text: "nested think",
+          parentCallId: "task-1",
+        },
+      }),
+      ev({ type: "turn.completed", turnId: "turn_1", data: {} }),
+    ]);
+
+    expect(traj.turns[0]?.reasoningText).toBe("parent think");
+  });
+
+  it("formatTrajectoryText includes nested subagent tools", () => {
+    const traj = buildTrajectory([
+      ev({
+        type: "subagent.called",
+        turnId: "turn_1",
+        data: { callId: "task-1", name: "worker", description: "do work" },
+      }),
+      ev({
+        type: "actions.requested",
+        turnId: "turn_1",
+        data: {
+          calls: [
+            {
+              callId: "read-1",
+              toolName: "read",
+              args: { path: "a.ts" },
+              parentCallId: "task-1",
+            },
+          ],
+        },
+      }),
+      ev({ type: "turn.completed", turnId: "turn_1", data: {} }),
+    ]);
+
+    const text = formatTrajectoryText(traj);
+    expect(text).toContain("task worker");
+    expect(text).toContain("read");
+  });
+});

package/src/internal/turn-governor.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { TurnGovernor, type TurnPermit } from "./turn-governor.js";
+
+describe("TurnGovernor", () => {
+  it("grants immediately with no limit configured", async () => {
+    const governor = new TurnGovernor(undefined);
+    expect(governor.limited).toBe(false);
+    const permit = await governor.acquire({ sessionId: "s1" });
+    expect(permit).toBeDefined();
+    expect(governor.queuedCount).toBe(0);
+    permit?.release();
+  });
+
+  it("queues FIFO beyond the limit and wakes waiters in order", async () => {
+    const governor = new TurnGovernor({ maxRunningTurns: 2 });
+    const first = await governor.acquire({ sessionId: "s1" });
+    const second = await governor.acquire({ sessionId: "s2" });
+    expect(governor.runningCount).toBe(2);
+
+    const positions: Array<{ sessionId: string; position: number }> = [];
+    const grants: string[] = [];
+    const third = governor
+      .acquire({
+        sessionId: "s3",
+        onQueued: (position) => positions.push({ sessionId: "s3", position }),
+      })
+      .then((permit) => {
+        grants.push("s3");
+        return permit;
+      });
+    const fourth = governor
+      .acquire({
+        sessionId: "s4",
+        onQueued: (position) => positions.push({ sessionId: "s4", position }),
+      })
+      .then((permit) => {
+        grants.push("s4");
+        return permit;
+      });
+
+    expect(positions).toEqual([
+      { sessionId: "s3", position: 1 },
+      { sessionId: "s4", position: 2 },
+    ]);
+    expect(governor.queuedCount).toBe(2);
+    expect(governor.isQueued("s3")).toBe(true);
+    expect(governor.isQueued("s4")).toBe(true);
+
+    first?.release();
+    const thirdPermit = await third;
+    expect(grants).toEqual(["s3"]);
+    expect(governor.isQueued("s3")).toBe(false);
+    expect(governor.runningCount).toBe(2);
+
+    second?.release();
+    const fourthPermit = await fourth;
+    expect(grants).toEqual(["s3", "s4"]);
+    expect(governor.queuedCount).toBe(0);
+
+    thirdPermit?.release();
+    fourthPermit?.release();
+    expect(governor.runningCount).toBe(0);
+  });
+
+  it("resolves undefined when the signal aborts while waiting", async () => {
+    const governor = new TurnGovernor({ maxRunningTurns: 1 });
+    const holder = await governor.acquire({ sessionId: "s1" });
+
+    const abort = new AbortController();
+    const waiting = governor.acquire({
+      sessionId: "s2",
+      signal: abort.signal,
+    });
+    expect(governor.isQueued("s2")).toBe(true);
+
+    abort.abort();
+    expect(await waiting).toBeUndefined();
+    expect(governor.isQueued("s2")).toBe(false);
+    expect(governor.queuedCount).toBe(0);
+
+    // The abandoned wait must not consume the slot when it frees.
+    holder?.release();
+    const next = await governor.acquire({ sessionId: "s3" });
+    expect(next).toBeDefined();
+    next?.release();
+  });
+
+  it("resolves undefined without enqueuing when already aborted", async () => {
+    const governor = new TurnGovernor({ maxRunningTurns: 1 });
+    const holder = await governor.acquire({ sessionId: "s1" });
+    const abort = new AbortController();
+    abort.abort();
+    let queued = false;
+    const permit = await governor.acquire({
+      sessionId: "s2",
+      signal: abort.signal,
+      onQueued: () => {
+        queued = true;
+      },
+    });
+    expect(permit).toBeUndefined();
+    expect(queued).toBe(false);
+    holder?.release();
+  });
+
+  it("release is idempotent", async () => {
+    const governor = new TurnGovernor({ maxRunningTurns: 1 });
+    const first = (await governor.acquire({ sessionId: "s1" })) as TurnPermit;
+    first.release();
+    first.release();
+    expect(governor.runningCount).toBe(0);
+    const second = await governor.acquire({ sessionId: "s2" });
+    expect(second).toBeDefined();
+    expect(governor.runningCount).toBe(1);
+    second?.release();
+  });
+
+  it("keeps FIFO order over grants freed by aborted waiters", async () => {
+    const governor = new TurnGovernor({ maxRunningTurns: 1 });
+    const holder = await governor.acquire({ sessionId: "s1" });
+    const abortSecond = new AbortController();
+    const second = governor.acquire({
+      sessionId: "s2",
+      signal: abortSecond.signal,
+    });
+    const third = governor.acquire({ sessionId: "s3" });
+
+    abortSecond.abort();
+    expect(await second).toBeUndefined();
+
+    holder?.release();
+    const thirdPermit = await third;
+    expect(thirdPermit).toBeDefined();
+    expect(governor.queuedCount).toBe(0);
+    thirdPermit?.release();
+  });
+});