@cursor/july 0.1.26 → 0.1.28

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

@@ -1,198 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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();
-  });
-});