@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/run/prepare.test.ts

@@ -1,428 +0,0 @@
-// Unit tests for the prelude orchestrator: flag validation helpers and the
-// STIGMER_ORG_ID injection rule. Attachment uploading is covered in
-// attachments.test.ts, so these tests use no attachments.
-
-import { describe, expect, it } from "vitest";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { Stigmer } from "@stigmer/sdk";
-import { type AgentExecFlags, parseApprovalAction, prepareAgentExec, validateHarness, validateMode, validateServiceTier, validateThinking } from "./prepare.js";
-
-describe("parseApprovalAction", () => {
-  it("maps each accepted value (case-insensitive)", () => {
-    expect(parseApprovalAction("")).toBe(ApprovalAction.UNSPECIFIED);
-    expect(parseApprovalAction("approve")).toBe(ApprovalAction.APPROVE);
-    expect(parseApprovalAction("SKIP")).toBe(ApprovalAction.SKIP);
-    expect(parseApprovalAction("reject")).toBe(ApprovalAction.REJECT);
-    expect(parseApprovalAction("approve-all")).toBe(ApprovalAction.APPROVE_ALL);
-    expect(parseApprovalAction("approve_all")).toBe(ApprovalAction.APPROVE_ALL);
-    expect(parseApprovalAction("approveall")).toBe(ApprovalAction.APPROVE_ALL);
-  });
-
-  it("rejects an unknown value", () => {
-    expect(() => parseApprovalAction("maybe")).toThrow(/must be one of/);
-  });
-});
-
-describe("validateMode", () => {
-  it("accepts empty, agent, and plan", () => {
-    expect(() => validateMode("")).not.toThrow();
-    expect(() => validateMode("agent")).not.toThrow();
-    expect(() => validateMode("plan")).not.toThrow();
-  });
-
-  it("rejects anything else", () => {
-    expect(() => validateMode("yolo")).toThrow(/must be "agent" or "plan"/);
-  });
-});
-
-describe("validateServiceTier", () => {
-  it("accepts empty, standard, and fast", () => {
-    expect(() => validateServiceTier("")).not.toThrow();
-    expect(() => validateServiceTier("standard")).not.toThrow();
-    expect(() => validateServiceTier("fast")).not.toThrow();
-  });
-
-  it("rejects anything else before a network round trip", () => {
-    expect(() => validateServiceTier("turbo")).toThrow(/must be "standard" or "fast"/);
-  });
-});
-
-describe("validateThinking", () => {
-  it("accepts empty, disabled, and enabled", () => {
-    expect(() => validateThinking("")).not.toThrow();
-    expect(() => validateThinking("disabled")).not.toThrow();
-    expect(() => validateThinking("enabled")).not.toThrow();
-  });
-
-  it("rejects anything else before a network round trip", () => {
-    expect(() => validateThinking("harder")).toThrow(/must be "disabled" or "enabled"/);
-  });
-});
-
-describe("validateHarness", () => {
-  it("accepts empty, native, and cursor", () => {
-    expect(() => validateHarness("")).not.toThrow();
-    expect(() => validateHarness("native")).not.toThrow();
-    expect(() => validateHarness("cursor")).not.toThrow();
-  });
-
-  it("rejects anything else before a network round trip", () => {
-    expect(() => validateHarness("turbo")).toThrow(/must be "native" or "cursor"/);
-  });
-
-  it("rejects UI-only harness names that have no proto mapping", () => {
-    // copilot/codex/etc. exist in display metadata but not on the wire —
-    // accepting them here would stamp UNSPECIFIED and silently run native.
-    expect(() => validateHarness("copilot")).toThrow(/must be "native" or "cursor"/);
-  });
-});
-
-const BASE_FLAGS: AgentExecFlags = {
-  message: "hi",
-  attach: [],
-  approveDefault: "",
-  verbose: false,
-  detach: false,
-  workspace: [],
-  branch: "",
-  commit: "",
-  env: [],
-  envFile: [],
-  secret: [],
-  secretFile: [],
-  model: "",
-  autoApprove: false,
-  mode: "",
-  serviceTier: "",
-  thinking: "",
-  harness: "",
-};
-
-// prepareAgentExec only touches client.agentExecution for attachment uploads;
-// with no attachments a bare stub suffices.
-const STUB_CLIENT = { agentExecution: {} } as unknown as Stigmer;
-
-/** The shape of IdentityAccountPreferences the stubs below expose. */
-interface StubPreferences {
-  readonly defaultHarness?: string;
-  readonly defaultNativeModel?: string;
-  readonly defaultCursorModel?: string;
-}
-
-/** Stub whose whoAmI resolves an account carrying the given preferences. */
-function clientWithPreferences(preferences: StubPreferences): Stigmer {
-  return {
-    agentExecution: {},
-    identityAccount: {
-      whoAmI: () => Promise.resolve({ spec: { preferences } }),
-    },
-  } as unknown as Stigmer;
-}
-
-/** Back-compat shorthand for the original native-model-only stub. */
-function clientWithPreference(defaultNativeModel: string): Stigmer {
-  return clientWithPreferences({ defaultNativeModel });
-}
-
-/** Stub whose whoAmI rejects (auth failure, backend without the RPC, ...). */
-function clientWithFailingWhoAmI(): Stigmer {
-  return {
-    agentExecution: {},
-    identityAccount: {
-      whoAmI: () => Promise.reject(new Error("unimplemented")),
-    },
-  } as unknown as Stigmer;
-}
-
-/** Preference stub that also counts whoAmI invocations (round-trip pin). */
-function countingClient(preferences: StubPreferences): { client: Stigmer; calls: () => number } {
-  let calls = 0;
-  const client = {
-    agentExecution: {},
-    identityAccount: {
-      whoAmI: () => {
-        calls += 1;
-        return Promise.resolve({ spec: { preferences } });
-      },
-    },
-  } as unknown as Stigmer;
-  return { client, calls: () => calls };
-}
-
-/** prepareAgentExec options as `run` passes them: the kind is served here. */
-const SERVED_RUN_OPTIONS = { accountPreferencesAvailable: true } as const;
-
-describe("prepareAgentExec env injection", () => {
-  it("injects STIGMER_ORG_ID when absent", async () => {
-    const prepared = await prepareAgentExec(BASE_FLAGS, STUB_CLIENT, "acme");
-    expect(prepared.runtimeEnv.STIGMER_ORG_ID).toEqual({ value: "acme", isSecret: false });
-  });
-
-  it("does not override an explicit STIGMER_ORG_ID", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, env: ["STIGMER_ORG_ID=explicit"] },
-      STUB_CLIENT,
-      "acme",
-    );
-    expect(prepared.runtimeEnv.STIGMER_ORG_ID).toEqual({ value: "explicit", isSecret: false });
-  });
-
-  it("skips injection when org is empty", async () => {
-    const prepared = await prepareAgentExec(BASE_FLAGS, STUB_CLIENT, "");
-    expect(prepared.runtimeEnv.STIGMER_ORG_ID).toBeUndefined();
-  });
-
-  it("carries through scalar flags", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, message: "go", model: "claude", autoApprove: true, detach: true, mode: "plan" },
-      STUB_CLIENT,
-      "acme",
-    );
-    expect(prepared.message).toBe("go");
-    expect(prepared.model).toBe("claude");
-    expect(prepared.autoApproveAll).toBe(true);
-    expect(prepared.detach).toBe(true);
-    expect(prepared.mode).toBe("plan");
-  });
-});
-
-describe("prepareAgentExec account-preference model fill (oss#293 Phase 1.5)", () => {
-  it("fills an omitted --model from the account preference on cloud", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreference("claude-sonnet-4.6"),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: true },
-    );
-    expect(prepared.model).toBe("claude-sonnet-4.6");
-  });
-
-  it("an explicit --model always outranks the preference", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, model: "gpt-5.3" },
-      clientWithPreference("claude-sonnet-4.6"),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: true },
-    );
-    expect(prepared.model).toBe("gpt-5.3");
-  });
-
-  it("never consults identity where the kind is not served", async () => {
-    // The failing stub doubles as a call detector: a backend that does not
-    // serve identity accounts must not even attempt whoAmI, so a rejecting
-    // client cannot affect the result. (20260911.11 A3: the gate is the
-    // kind's tier, not the backend type — client/edition.ts resourceServedOn.)
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithFailingWhoAmI(),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: false },
-    );
-    expect(prepared.model).toBe("");
-  });
-
-  it("falls through silently when whoAmI fails — a missing preference never fails a run", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithFailingWhoAmI(),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: true },
-    );
-    expect(prepared.model).toBe("");
-  });
-
-  it("stays empty when the account declares no native default", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreference(""),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: true },
-    );
-    expect(prepared.model).toBe("");
-  });
-});
-
-describe("prepareAgentExec harness resolution (oss#293)", () => {
-  it("fills an omitted --harness from the account preference on cloud when the caller opts in (run)", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreferences({ defaultHarness: "cursor" }),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("cursor");
-  });
-
-  it("an explicit --harness always outranks the account preference", async () => {
-    // The per-run escape hatch: a cursor-preference user can still force a
-    // native run without touching their settings.
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "native" },
-      clientWithPreferences({ defaultHarness: "cursor" }),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("native");
-  });
-
-  it("an explicit --harness resolves as given when the server serves no account preferences", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "cursor" },
-      STUB_CLIENT,
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: false },
-    );
-    expect(prepared.harness).toBe("cursor");
-  });
-
-  it("treats a malformed persisted harness as undeclared", async () => {
-    // A client must not trust stored data it did not write: anything outside
-    // the shipped allowlist resolves as if no preference existed.
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreferences({ defaultHarness: "devin" }),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("");
-  });
-
-  it("resolves empty when whoAmI fails — a missing preference never fails a run", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithFailingWhoAmI(),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("");
-    expect(prepared.model).toBe("");
-  });
-
-  it("never consults identity on a local backend, even with the opt-in", async () => {
-    // The failing stub doubles as a call detector, as in the model-fill suite.
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithFailingWhoAmI(),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: false },
-    );
-    expect(prepared.harness).toBe("");
-  });
-
-  it("resolves empty when nothing is declared anywhere", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreferences({}),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("");
-  });
-});
-
-describe("prepareAgentExec harness-aware model fill (oss#293)", () => {
-  const BOTH_MODELS: StubPreferences = {
-    defaultNativeModel: "claude-sonnet-4.6",
-    defaultCursorModel: "composer-2.5",
-  };
-
-  it("fills the cursor model when the explicit harness is cursor", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "cursor" },
-      clientWithPreferences(BOTH_MODELS),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.model).toBe("composer-2.5");
-  });
-
-  it("fills the cursor model when the preference resolves the harness to cursor", async () => {
-    const prepared = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreferences({ ...BOTH_MODELS, defaultHarness: "cursor" }),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.harness).toBe("cursor");
-    expect(prepared.model).toBe("composer-2.5");
-  });
-
-  it("fills the native model when the harness resolves native or empty", async () => {
-    const explicit = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "native" },
-      clientWithPreferences(BOTH_MODELS),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(explicit.model).toBe("claude-sonnet-4.6");
-
-    const unset = await prepareAgentExec(
-      BASE_FLAGS,
-      clientWithPreferences(BOTH_MODELS),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(unset.model).toBe("claude-sonnet-4.6");
-  });
-
-  it("an explicit --model outranks the harness-matched preference", async () => {
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "cursor", model: "gpt-5.3" },
-      clientWithPreferences(BOTH_MODELS),
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(prepared.model).toBe("gpt-5.3");
-  });
-
-  it("draft with an explicit --harness cursor fills the cursor model despite no harness opt-in (D5)", async () => {
-    // D5 scopes only the silent preference fill; the model fill follows
-    // whatever harness the user explicitly chose.
-    const prepared = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "cursor" },
-      clientWithPreferences(BOTH_MODELS),
-      "acme",
-      undefined,
-      { accountPreferencesAvailable: true },
-    );
-    expect(prepared.harness).toBe("cursor");
-    expect(prepared.model).toBe("composer-2.5");
-  });
-
-  it("serves both fills from one whoAmI round trip, and none when both flags are explicit", async () => {
-    const single = countingClient({ ...BOTH_MODELS, defaultHarness: "cursor" });
-    const filled = await prepareAgentExec(BASE_FLAGS, single.client, "acme", undefined, SERVED_RUN_OPTIONS);
-    expect(filled.harness).toBe("cursor");
-    expect(filled.model).toBe("composer-2.5");
-    expect(single.calls(), "harness + model fills share one whoAmI").toBe(1);
-
-    const skipped = countingClient(BOTH_MODELS);
-    const explicit = await prepareAgentExec(
-      { ...BASE_FLAGS, harness: "native", model: "gpt-5.3" },
-      skipped.client,
-      "acme",
-      undefined,
-      SERVED_RUN_OPTIONS,
-    );
-    expect(explicit.harness).toBe("native");
-    expect(explicit.model).toBe("gpt-5.3");
-    expect(skipped.calls(), "explicit flags leave nothing to fill — no round trip").toBe(0);
-  });
-});

package/src/resources/run/workflow-stream.integration.test.ts

@@ -1,157 +0,0 @@
-// In-process integration test for live `run workflow` streaming.
-//
-// Stands up a real Connect backend serving workflowExecution.subscribeEvents
-// (the canonical event stream) plus get + submitApproval, points an SDK node
-// client at it, and drives streamWorkflowExecution end to end: NDJSON vs inline
-// rendering (D-WF-1), policy-driven approval submission on approval_requested,
-// terminal-event stop, and the final-Get epilogue summary.
-
-import { create } from "@bufbuild/protobuf";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { WorkflowExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
-import { WorkflowExecutionCommandController } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/command_pb";
-import { ExecutionPhase, WorkflowTaskStatus } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
-import {
-  type WorkflowExecutionEvent,
-  WorkflowExecutionEventSchema,
-  WorkflowEventType,
-} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
-import type { SubmitWorkflowApprovalInput } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/io_pb";
-import { WorkflowExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/query_pb";
-import type { Stigmer } from "@stigmer/sdk";
-import { createNodeClient, normalizeEndpoint } from "@stigmer/sdk/node";
-import { createServer as createHttp2Server, type Http2Server, type ServerHttp2Session } from "node:http2";
-import type { AddressInfo } from "node:net";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { streamWorkflowExecution, type WorkflowStreamStreams } from "./workflow-stream.js";
-
-let backend: Http2Server;
-let client: Stigmer;
-const openSessions = new Set<ServerHttp2Session>();
-let approvals: SubmitWorkflowApprovalInput[] = [];
-
-beforeEach(() => {
-  approvals = [];
-});
-
-// Final state returned by the epilogue Get: one task done, one failed.
-const finalExec = create(WorkflowExecutionSchema, {
-  metadata: { id: "wex_1", name: "Deploy" },
-  status: {
-    phase: ExecutionPhase.EXECUTION_COMPLETED,
-    startedAt: "2026-06-12T10:00:00Z",
-    completedAt: "2026-06-12T10:01:30Z",
-    tasks: [
-      { taskName: "build", status: WorkflowTaskStatus.WORKFLOW_TASK_COMPLETED },
-      { taskName: "ship", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED },
-    ],
-  },
-});
-
-function event(type: WorkflowEventType, payload: WorkflowExecutionEvent["payload"], taskName = "") {
-  return create(WorkflowExecutionEventSchema, { eventType: type, occurredAt: "2026-06-12T10:00:01Z", taskName, payload });
-}
-
-beforeAll(async () => {
-  const routes = (router: ConnectRouter) => {
-    router.service(WorkflowExecutionQueryController, {
-      get: () => finalExec,
-      subscribeEvents: async function* () {
-        yield event(WorkflowEventType.execution_started, { case: "executionStarted", value: {} as never });
-        yield event(WorkflowEventType.task_started, { case: "taskStarted", value: {} as never }, "build");
-        yield event(
-          WorkflowEventType.approval_requested,
-          { case: "approvalRequested", value: { toolCallId: "tc_99", prompt: "delete prod?" } as never },
-          "ship",
-        );
-        yield event(WorkflowEventType.execution_completed, { case: "executionCompleted", value: {} as never });
-      },
-    });
-    router.service(WorkflowExecutionCommandController, {
-      submitApproval: (req) => (approvals.push(req), finalExec),
-    });
-  };
-
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-  client = createNodeClient({ baseUrl: normalizeEndpoint(`127.0.0.1:${port}`) });
-});
-
-afterAll(async () => {
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-});
-
-function capture(): { streams: WorkflowStreamStreams; data: () => string; status: () => string } {
-  const out: string[] = [];
-  const err: string[] = [];
-  return {
-    streams: { data: (l) => out.push(l), status: (l) => err.push(l), colorize: false },
-    data: () => out.join(""),
-    status: () => err.join("\n"),
-  };
-}
-
-describe("live run workflow streaming", () => {
-  it("renders inline plaintext, auto-resolves approval, and prints the epilogue", async () => {
-    const cap = capture();
-    const result = await streamWorkflowExecution(
-      { client, executionId: "wex_1", outputMode: "inline", defaultAction: ApprovalAction.APPROVE },
-      cap.streams,
-    );
-
-    const data = cap.data();
-    expect(data).toContain("execution started");
-    expect(data).toContain("task started: build");
-    expect(data).toContain("approval requested: ship — delete prod?");
-    expect(data).toContain("execution completed");
-
-    // Policy resolved the approval: one submit with the right tool call + action.
-    expect(approvals).toHaveLength(1);
-    expect(approvals[0].toolCallId).toBe("tc_99");
-    expect(approvals[0].action).toBe(ApprovalAction.APPROVE);
-    expect(cap.status()).toContain("Approval auto-resolved (approve) for tc_99");
-
-    // Epilogue summary from the final Get.
-    expect(cap.status()).toContain("Workflow completed");
-    expect(cap.status()).toContain("1 completed");
-    expect(cap.status()).toContain("1 failed");
-    expect(result.metadata?.id).toBe("wex_1");
-  });
-
-  it("emits NDJSON event envelopes with canonical type names (D-WF-1)", async () => {
-    const cap = capture();
-    await streamWorkflowExecution(
-      { client, executionId: "wex_1", outputMode: "json", defaultAction: ApprovalAction.APPROVE },
-      cap.streams,
-    );
-
-    const lines = cap.data().trim().split("\n").map((l) => JSON.parse(l));
-    expect(lines.map((e) => e.type)).toEqual([
-      "execution_started",
-      "task_started",
-      "approval_requested",
-      "execution_completed",
-    ]);
-    const approval = lines.find((e) => e.type === "approval_requested");
-    expect(approval.payload.task).toBe("ship");
-  });
-
-  it("leaves the approval for the user when no policy is configured", async () => {
-    const cap = capture();
-    await streamWorkflowExecution(
-      { client, executionId: "wex_1", outputMode: "inline", defaultAction: ApprovalAction.UNSPECIFIED },
-      cap.streams,
-    );
-
-    expect(approvals).toHaveLength(0);
-    expect(cap.status()).toContain("stigmer execution approve wex_1 --tool-call tc_99 --action approve");
-  });
-});

package/src/resources/run/workspace.test.ts

@@ -1,93 +0,0 @@
-// Unit tests for workspace flag parsing: git vs local variant selection, SSH
-// rejection, branch/commit applicability rules, name derivation, and duplicate
-// detection.
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { localWorkspaceRoots, parseWorkspaceEntries, workspaceNames } from "./workspace.js";
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "ws-test-"));
-});
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-describe("parseWorkspaceEntries (git)", () => {
-  it("builds a GitRepoSource with branch and commit", () => {
-    const entries = parseWorkspaceEntries(["https://github.com/acme/my-app.git"], "main", "abc123");
-    expect(entries).toHaveLength(1);
-    expect(entries[0].name).toBe("my-app");
-    const source = entries[0].source;
-    expect(source?.source.case).toBe("gitRepo");
-    if (source?.source.case === "gitRepo") {
-      expect(source.source.value.url).toBe("https://github.com/acme/my-app.git");
-      expect(source.source.value.branch).toBe("main");
-      expect(source.source.value.commit).toBe("abc123");
-    }
-  });
-
-  it("derives the repo name from a URL without .git or trailing slash", () => {
-    expect(parseWorkspaceEntries(["https://github.com/acme/repo/"], "", "")[0].name).toBe("repo");
-  });
-
-  it("rejects SSH git URLs with HTTPS guidance", () => {
-    expect(() => parseWorkspaceEntries(["git@github.com:acme/x.git"], "", "")).toThrow(/SSH git URLs are not supported/);
-  });
-});
-
-describe("parseWorkspaceEntries (local)", () => {
-  it("builds a LocalPathSource from an existing directory", () => {
-    const entries = parseWorkspaceEntries([dir], "", "");
-    expect(entries[0].name).toBe(basename(dir));
-    expect(entries[0].source?.source.case).toBe("localPath");
-    if (entries[0].source?.source.case === "localPath") {
-      expect(entries[0].source.source.value.path).toBe(dir);
-    }
-  });
-
-  it("rejects a non-existent local path", () => {
-    expect(() => parseWorkspaceEntries([join(dir, "missing")], "", "")).toThrow(/does not exist/);
-  });
-
-  it("rejects --branch/--commit on a local workspace", () => {
-    expect(() => parseWorkspaceEntries([dir], "main", "")).toThrow(/only valid with git workspace/);
-  });
-});
-
-describe("parseWorkspaceEntries (rules)", () => {
-  it("returns an empty list when no workspace is given", () => {
-    expect(parseWorkspaceEntries([], "", "")).toEqual([]);
-  });
-
-  it("rejects --branch/--commit without --workspace", () => {
-    expect(() => parseWorkspaceEntries([], "main", "")).toThrow(/require --workspace/);
-  });
-
-  it("rejects --branch/--commit with more than one workspace", () => {
-    expect(() =>
-      parseWorkspaceEntries(["https://github.com/a/b.git", "https://github.com/c/d.git"], "main", ""),
-    ).toThrow(/single git workspace/);
-  });
-
-  it("rejects duplicate derived names", () => {
-    expect(() =>
-      parseWorkspaceEntries(["https://github.com/a/dup.git", "https://github.com/b/dup.git"], "", ""),
-    ).toThrow(/duplicate workspace name/);
-  });
-});
-
-describe("derived helpers", () => {
-  it("localWorkspaceRoots returns only local paths", () => {
-    const entries = parseWorkspaceEntries([dir, "https://github.com/a/b.git"], "", "");
-    expect(localWorkspaceRoots(entries)).toEqual([dir]);
-  });
-
-  it("workspaceNames returns every entry name", () => {
-    const entries = parseWorkspaceEntries([dir, "https://github.com/a/b.git"], "", "");
-    expect(workspaceNames(entries)).toEqual([basename(dir), "b"]);
-  });
-});