@lizard-build/cli 4.0.36 → 4.0.38

package/src/commands/git.ts

@@ -81,7 +81,7 @@ export function registerGit(program: Command) {
 
       if (newStatus.installed) {
         success("GitHub connected! You can now deploy private repositories.");
-        info(chalk.dim("  Run `lizard deploy` to deploy your project."));
+        info(chalk.dim("  Run `lizard add -r owner/repo` to deploy a repository, or `lizard redeploy` if a service already tracks it."));
       } else {
         fail("GitHub App not detected. Please try again or connect via the dashboard.");
       }

package/src/commands/init.ts

@@ -44,6 +44,8 @@ export async function ensureLinked(opts: {
   workspaceFlag?: string;
   force?: boolean;
   relinkPrompt?: boolean;
+  /** Link an unlinked folder to the account's default project instead of asking (`lizard up`). */
+  useDefault?: boolean;
 } = {}): Promise<ProjectLink> {
   const existing = getProjectLink();
 
@@ -62,6 +64,25 @@ export async function ensureLinked(opts: {
     if (p.isCancel(proceed) || !proceed) return existing;
   }
 
+  // `lizard up` in a folder that was never linked: link it to the default
+  // project rather than ask, so a first deploy needs no `lizard init`. The link
+  // is what keeps the next `up` from this folder on the same service.
+  if (!existing && opts.useDefault && !opts.projectName && !opts.workspaceFlag) {
+    const { defaultProject } = await import("../lib/default-project.js");
+    const fallback = await defaultProject();
+    if (fallback) {
+      const link: ProjectLink = {
+        projectId: fallback.id,
+        projectName: fallback.name,
+        workspaceId: fallback.workspaceId,
+        workspaceName: fallback.workspaceName,
+      };
+      setProjectLink(link);
+      info(chalk.dim(`Linked this folder to ${fallback.name}, your default project. Run \`lizard init --force\` to pick another.`));
+      return link;
+    }
+  }
+
   // 1. Workspace
   const workspaces = await fetchWorkspaces();
   const workspace = await pickWorkspace({

package/src/commands/login.ts

@@ -97,29 +97,37 @@ export function accountInstruction(state: AccountState, sub: Subscription | null
   }
 }
 
-/** Commands an agent can run next. Sandboxes first; both they and deploys live in a project. */
+/**
+ * Commands an agent can run next. Sandboxes first. Neither needs `lizard init`:
+ * an unlinked folder uses the account's default project.
+ */
 export function nextSteps(linked: boolean): Array<{ command: string; why: string }> {
   return [
     {
       command: "lizard skills get core",
       why: "The guide to every command, matched to this CLI version. Read it before running others.",
     },
-    ...(linked
-      ? []
-      : [{ command: "lizard init", why: "Create a project and link the current folder to it. Sandboxes and deploys both need one." }]),
     {
       command: "lizard sandbox create",
-      why: "Start a sandbox in the project, then run commands in it with `lizard sandbox exec <id> -- <cmd>`.",
+      why:
+        (linked
+          ? "Start a sandbox in the linked project"
+          : "Start a sandbox in the account's default project (--project picks another)") +
+        ", then run commands in it with `lizard sandbox exec <id> -- <cmd>`.",
+    },
+    {
+      command: "lizard up",
+      why: linked
+        ? "Or deploy the linked folder."
+        : "Or deploy this folder. It is linked to the default project first; `lizard init` picks another.",
     },
-    { command: "lizard up", why: "Or deploy the linked folder." },
   ];
 }
 
 /** The same steps for a person, as aligned lines for the closing note. */
-export function nextStepsNote(linked: boolean): string {
+export function nextStepsNote(): string {
   const rows: Array<[string, string]> = [
-    ...(linked ? [] : ([["lizard init", "Create a project and link this folder"]] as Array<[string, string]>)),
-    ["lizard sandbox create", linked ? "Start a sandbox in this project" : "Start a sandbox in it"],
+    ["lizard sandbox create", "Start a sandbox"],
     ["lizard up", "Or deploy this folder"],
   ];
   const width = Math.max(...rows.map(([cmd]) => cmd.length)) + 3;
@@ -221,7 +229,7 @@ async function loginInteractive(flag?: AuthProvider): Promise<void> {
 
   await offerPlan(canAsk);
 
-  p.note(nextStepsNote(Boolean(getProjectLink())), "Next");
+  p.note(nextStepsNote(), "Next");
   p.outro("You're all set");
 }
 

package/src/commands/restart.ts

@@ -57,6 +57,9 @@ export function registerRestart(program: Command) {
         }
       }
 
+      // `ps` takes no service argument: it lists every service in the project.
+      const psHint = `lizard ps${opts.project ? ` --project ${opts.project}` : ""}`;
+
       const timeoutSeconds = parseInt(opts.timeout, 10);
       if (!(timeoutSeconds > 0)) {
         fail(`--timeout must be a positive number of seconds, got ${JSON.stringify(opts.timeout)}`, 1, "INVALID_ARGUMENT");
@@ -104,7 +107,7 @@ export function registerRestart(program: Command) {
           printJSON({ id, status: "restarting" });
         } else {
           success("Restart started");
-          info(chalk.dim(`  Check status: lizard ps ${id}`));
+          info(chalk.dim(`  Check status: ${psHint}`));
         }
         return;
       }
@@ -138,7 +141,7 @@ export function registerRestart(program: Command) {
       } else if (finalStatus) {
         error("Restart failed");
       } else {
-        info(chalk.dim("Still restarting — check status with: lizard ps " + id));
+        info(chalk.dim(`Still restarting — check status with: ${psHint}`));
       }
     });
 }

package/src/commands/sandbox.ts

@@ -9,7 +9,7 @@ import open from "open";
 import { api, APIError, getBaseURL, getRawBytes, apiErrorFrom, clientHeaders, getRequestToken, withQuery, withScope, type ResourceScope } from "../lib/api.js";
 import { getToken } from "../lib/auth.js";
 import { resolveProjectScope } from "../lib/resolve.js";
-import { resolveProjectId } from "../lib/config.js";
+import { getProjectLink, resolveProjectId } from "../lib/config.js";
 import { resolveVolume } from "../lib/volume.js";
 import { sandboxShell } from "./sandbox-ssh.js";
 import { startVncTunnel, vncTarget } from "./sandbox-vnc.js";
@@ -45,6 +45,9 @@ interface SandboxRecord {
   endAt?: number | string;
   expiresAt?: number | string;
   projectId?: string | null;
+  /** Set by the platform when nothing named a project and it used the account's default. */
+  projectName?: string;
+  projectDefaulted?: boolean;
 }
 
 function parseIntOption(v: string): number {
@@ -117,7 +120,13 @@ export function registerSandbox(program: Command) {
       // its workspaceId, which the create endpoint looks up itself anyway, overlapped
       // with auth so it costs the server nothing. Sending it bought nothing and cost the
       // client a round trip — 113ms of a 1083ms create measured from EU.
-      const projectId = await resolveProjectId(opts.project);
+      //
+      // Unlinked and no --project: send no project, and the platform puts the sandbox in
+      // the account's default project. Asking for that project first would cost every
+      // such create a round trip. A volume name is only unique within a project, so
+      // --volume still resolves one here.
+      const named = Boolean(opts.project || getProjectLink()?.projectId || opts.volume);
+      const projectId = named ? await resolveProjectId(opts.project) : undefined;
       const scope = { workspaceId: null };
 
       // Hand the volume to the create call instead of resolving it first.
@@ -173,8 +182,12 @@ export function registerSandbox(program: Command) {
         } catch (e: any) {
           // Only an id-shaped guess can be wrong this way, and only by 404. Anything
           // else (409 already-attached, 400 wrong scope) is a real answer — rethrow it.
+          // An older platform, or a workspace without any project.
+          if (e instanceof APIError && e.code === "PROJECT_REQUIRED") {
+            throw new Error("No project linked. Run `lizard init` or pass --project <id>.");
+          }
           if (!volumeId || e?.status !== 404) throw e;
-          const resolved = await resolveVolume(projectId, scope, opts.volume);
+          const resolved = await resolveVolume(projectId!, scope, opts.volume);
           sandbox = await api.post<SandboxRecord>("/api/sandboxes", {
             ...body, volumeId: resolved.id, volumeName: undefined,
           });
@@ -190,6 +203,9 @@ export function registerSandbox(program: Command) {
         return;
       }
       success(`Sandbox ${chalk.bold(sandbox.id)} created`);
+      if (sandbox.projectDefaulted && sandbox.projectName) {
+        info(chalk.dim(`  Project: ${sandbox.projectName} (your default; pass --project for another)`));
+      }
       info(chalk.dim(`  Template: ${sandbox.template}  Region: ${sandbox.region}`));
       const machine = `${sandbox.cpus} vCPU / ${sandbox.memoryMb} MB`;
       info(chalk.dim(sandbox.size

package/src/commands/ssh.ts

@@ -11,7 +11,7 @@ import * as http from "node:http";
 export function registerSSH(program: Command) {
   program
     .command("ssh")
-    .description("Execute a command inside a running service container")
+    .description("Execute a command inside a running service container (disabled: the API answers 403 \"Shell access to services is disabled\"; for sandboxes use `lizard sandbox ssh`)")
     .argument("[cmd...]", "Command and args to run inside the container (required; pass after `--` to stop flag parsing, e.g. `-- ls -la /app`)")
     .option("-s, --service <id>", "Service name or ID")
     .option("-p, --project <id>", "Project name, slug, or ID")

package/src/commands/up.ts

@@ -59,8 +59,8 @@ export function registerUp(program: Command) {
       const projectFlag = merged.project;
       const region: string | undefined = opts.region;
 
-      // Run init flow if cwd isn't linked yet
-      await ensureLinked({ projectName: projectFlag });
+      // An unlinked folder goes to the default project (or --project, or init's questions)
+      await ensureLinked({ projectName: projectFlag, useDefault: true });
 
       // Resolve target service: --service flag → linked → first-in-project → prompt-or-fail
       const ctx = await resolveContext({

package/src/commands/upgrade.ts

@@ -1,7 +1,14 @@
 import chalk from "chalk";
 import { Command } from "commander";
 import { info, success, isJSONMode, printJSON } from "../lib/format.js";
-import { CURRENT_VERSION, getLatestVersion, selfUpdate, isStandaloneBinary } from "../lib/updater.js";
+import {
+  CURRENT_VERSION,
+  canSelfUpdate,
+  getLatestVersion,
+  installerCommand,
+  isStandaloneBinary,
+  selfUpdate,
+} from "../lib/updater.js";
 
 export function registerUpgrade(program: Command) {
   program
@@ -87,21 +94,40 @@ export function registerUpgrade(program: Command) {
         return;
       }
 
+      // No binary to swap in (the Windows build): say so and fail, instead of
+      // reporting an upgrade that never happened.
+      if (!canSelfUpdate()) {
+        throw notInstalled(`v${latest} is available, but this copy of Lizard CLI can't update itself.`);
+      }
+
       info(`Upgrading v${CURRENT_VERSION} → ${chalk.green("v" + latest)}...`);
 
+      let upgraded: boolean;
       try {
-        await selfUpdate((msg) => info(chalk.dim(msg)));
-        if (isJSONMode()) {
-          printJSON({
-            previousVersion: CURRENT_VERSION,
-            latestVersion: latest,
-            upgraded: true,
-          });
-        } else {
-          success(`Upgraded to v${latest}`);
-        }
+        upgraded = await selfUpdate((msg) => info(chalk.dim(msg)));
       } catch (e: any) {
         throw new Error(`Upgrade failed: ${e.message}`);
       }
+      if (!upgraded) {
+        throw notInstalled(`Nothing was replaced: v${CURRENT_VERSION} is still installed.`);
+      }
+      if (isJSONMode()) {
+        printJSON({
+          previousVersion: CURRENT_VERSION,
+          latestVersion: latest,
+          upgraded: true,
+        });
+      } else {
+        success(`Upgraded to v${latest}`);
+      }
     });
 }
+
+/** Exit 1 with the installer command that does the upgrade instead. */
+function notInstalled(reason: string): Error {
+  const shell = process.platform === "win32" ? " in PowerShell" : "";
+  return Object.assign(
+    new Error(`${reason} Re-run the installer${shell}:\n  ${installerCommand()}`),
+    { code: "UPGRADE_NOT_INSTALLED" },
+  );
+}

package/src/lib/config.ts

@@ -132,6 +132,13 @@ export async function resolveProjectId(flagValue?: string): Promise<string> {
   if (!flagValue) {
     const link = getProjectLink();
     if (link?.projectId) return link.projectId;
+    // Not linked: the account's default project, the one it got at sign-up.
+    const { defaultProject, noteDefaultProject } = await import("./default-project.js");
+    const fallback = await defaultProject();
+    if (fallback) {
+      noteDefaultProject(fallback.name);
+      return fallback.id;
+    }
     throw new Error("No project linked. Run `lizard init` or pass --project <id>.");
   }
   // A value that already looks like a project id needs no lookup. Project ids are

package/src/lib/default-project.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { api, APIError } from "./api.js";
+import { info } from "./format.js";
+
+// The project a command uses when the folder is not linked and no --project is
+// given: the platform's default for this account (GET /api/projects/default),
+// the oldest project in the personal workspace. Every account gets one at
+// sign-up, so `lizard sandbox create` or `lizard up` from any folder works
+// without `lizard init` first.
+
+export interface DefaultProject {
+  id: string;
+  name: string;
+  slug: string;
+  workspaceId: string;
+  workspaceName: string;
+}
+
+let lookup: Promise<DefaultProject | null> | undefined;
+
+/**
+ * The default project, asked once per run. Null when the account has none, or
+ * when the platform predates the route; callers then fail as they always did.
+ * 401 still throws: that is a sign-in problem, not a missing project.
+ */
+export function defaultProject(): Promise<DefaultProject | null> {
+  lookup ??= api.get<DefaultProject>("/api/projects/default").catch((err) => {
+    if (err instanceof APIError && err.status !== 401 && err.status >= 400 && err.status < 500) return null;
+    throw err;
+  });
+  return lookup;
+}
+
+let noted = false;
+
+/** Say once per run which project an unlinked folder ended up in, and how to choose another. */
+export function noteDefaultProject(name: string): void {
+  if (noted) return;
+  noted = true;
+  info(chalk.dim(`Project: ${name} (your default). Pass --project for another, or run \`lizard init\` to link this folder.`));
+}
+
+/** For tests: forget the cached answer. */
+export function resetDefaultProject(): void {
+  lookup = undefined;
+  noted = false;
+}

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "4.0.36";
+export const CURRENT_VERSION = "4.0.38";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
 
@@ -22,6 +22,22 @@ function getBinaryName(): string | null {
   return null;
 }
 
+/**
+ * True when selfUpdate() has a release asset to swap in for this platform.
+ * False on Windows: a running .exe can't be replaced in place, so the
+ * PowerShell installer does the update there.
+ */
+export function canSelfUpdate(): boolean {
+  return getBinaryName() !== null;
+}
+
+/** The installer that puts the latest standalone binary over this one. */
+export function installerCommand(): string {
+  return process.platform === "win32"
+    ? "irm https://lizard.build/api/cli/install.ps1 | iex"
+    : "curl -fsSL https://lizard.build/install.sh | bash";
+}
+
 /**
  * True only when running as the Bun-compiled standalone binary. Under
  * npm/node, `process.execPath` is the *node* executable — self-update would

package/test/unit/default-project.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveProjectId, getProjectLink, setProjectLink } from "../../src/lib/config.js";
+import { resetDefaultProject } from "../../src/lib/default-project.js";
+import { ensureLinked } from "../../src/commands/init.js";
+import { setBaseURL, setAccessToken } from "../../src/lib/api.js";
+import { setJSONMode } from "../../src/lib/format.js";
+
+const fetchMock = vi.fn();
+let tmpHome: string;
+let tmpCwd: string;
+let cwd: string;
+const savedHome = process.env.LIZARD_HOME;
+
+const project = { id: "p-default", name: "ada's Project", slug: "ada", workspaceId: "ws-1", workspaceName: "ada" };
+
+function reply(status: number, body: unknown) {
+  return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+}
+
+function routes(table: Record<string, () => Response>) {
+  fetchMock.mockImplementation(async (url: string, init?: RequestInit) => {
+    const key = `${init?.method ?? "GET"} ${new URL(url).pathname}`;
+    return table[key]?.() ?? reply(404, { error: `no route ${key}` });
+  });
+}
+
+const requested = () => fetchMock.mock.calls.map(([url, init]) => `${init?.method ?? "GET"} ${new URL(url).pathname}`);
+
+beforeEach(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "lizard-default-home-"));
+  tmpCwd = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "lizard-default-cwd-")));
+  process.env.LIZARD_HOME = tmpHome;
+  cwd = process.cwd();
+  process.chdir(tmpCwd);
+  fetchMock.mockReset();
+  vi.stubGlobal("fetch", fetchMock);
+  setBaseURL("https://lizard.build");
+  setAccessToken("tok");
+  setJSONMode(true);
+  resetDefaultProject();
+});
+
+afterEach(() => {
+  process.chdir(cwd);
+  if (savedHome === undefined) delete process.env.LIZARD_HOME;
+  else process.env.LIZARD_HOME = savedHome;
+  vi.unstubAllGlobals();
+  setJSONMode(false);
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  fs.rmSync(tmpCwd, { recursive: true, force: true });
+});
+
+describe("resolveProjectId in an unlinked folder", () => {
+  test("uses the account's default project, asking the platform once per run", async () => {
+    routes({ "GET /api/projects/default": () => reply(200, project) });
+    expect(await resolveProjectId()).toBe("p-default");
+    expect(await resolveProjectId()).toBe("p-default");
+    expect(requested()).toEqual(["GET /api/projects/default"]);
+  });
+
+  test("a linked folder or --project never asks for it", async () => {
+    setProjectLink({ projectId: "p-linked" });
+    expect(await resolveProjectId()).toBe("p-linked");
+    expect(await resolveProjectId("abcdefghijklmnopqrstu")).toBe("abcdefghijklmnopqrstu");
+    expect(requested()).toEqual([]);
+  });
+
+  test("no default project, or a platform without the route: the old error", async () => {
+    routes({ "GET /api/projects/default": () => reply(404, { error: "none", code: "NO_DEFAULT_PROJECT" }) });
+    await expect(resolveProjectId()).rejects.toThrow("No project linked. Run `lizard init` or pass --project <id>.");
+  });
+
+  test("a sign-in problem is not mistaken for a missing project", async () => {
+    routes({ "GET /api/projects/default": () => reply(401, { error: "Unauthorized" }) });
+    await expect(resolveProjectId()).rejects.toMatchObject({ status: 401 });
+  });
+});
+
+describe("lizard up in an unlinked folder", () => {
+  test("links the folder to the default project without asking", async () => {
+    routes({ "GET /api/projects/default": () => reply(200, project) });
+    const link = await ensureLinked({ useDefault: true });
+
+    expect(link).toEqual({ projectId: "p-default", projectName: "ada's Project", workspaceId: "ws-1", workspaceName: "ada" });
+    expect(getProjectLink()).toMatchObject({ projectId: "p-default" });
+    expect(requested()).toEqual(["GET /api/projects/default"]);
+  });
+
+  test("--project, or lizard init itself, still goes through the old flow", async () => {
+    routes({});
+    await expect(ensureLinked({ useDefault: true, projectName: "api" })).rejects.toThrow();
+    await expect(ensureLinked({})).rejects.toThrow();
+    expect(requested()).not.toContain("GET /api/projects/default");
+  });
+
+  test("an already linked folder stays as it is", async () => {
+    setProjectLink({ projectId: "p-linked" });
+    expect((await ensureLinked({ useDefault: true })).projectId).toBe("p-linked");
+    expect(requested()).toEqual([]);
+  });
+});

package/test/unit/login.test.ts

@@ -186,20 +186,17 @@ describe("account state", () => {
 
   test("the closing note leads with sandboxes, aligned in two columns", () => {
     const plain = (t: string) => t.replace(/\x1b\[[0-9;]*m/g, "");
-    expect(plain(nextStepsNote(false)).split("\n")).toEqual([
-      "lizard init             Create a project and link this folder",
-      "lizard sandbox create   Start a sandbox in it",
-      "lizard up               Or deploy this folder",
-    ]);
-    expect(plain(nextStepsNote(true)).split("\n")).toEqual([
-      "lizard sandbox create   Start a sandbox in this project",
+    expect(plain(nextStepsNote()).split("\n")).toEqual([
+      "lizard sandbox create   Start a sandbox",
       "lizard up               Or deploy this folder",
     ]);
   });
 
-  test("an unlinked folder gets lizard init before lizard up", () => {
-    expect(nextSteps(false).map((s) => s.command)).toEqual(["lizard skills get core", "lizard init", "lizard sandbox create", "lizard up"]);
+  test("no lizard init needed: an unlinked folder uses the default project", () => {
+    expect(nextSteps(false).map((s) => s.command)).toEqual(["lizard skills get core", "lizard sandbox create", "lizard up"]);
+    expect(nextSteps(false)[1].why).toContain("default project");
     expect(nextSteps(true).map((s) => s.command)).toEqual(["lizard skills get core", "lizard sandbox create", "lizard up"]);
+    expect(nextSteps(true)[1].why).toContain("linked project");
   });
 });
 
@@ -239,7 +236,7 @@ describe("lizard login --json", () => {
     expect(out).toMatchObject({ status: "complete", username: "ada", email: "ada@example.com", source: "browser" });
     expect(out.account.state).toBe("trial_available");
     expect(out.account.billingUrl).toBe("https://lizard.build/profile/account-billing");
-    expect(out.next.map((s: { command: string }) => s.command)).toContain("lizard init");
+    expect(out.next.map((s: { command: string }) => s.command)).toContain("lizard sandbox create");
     expect(loadConfig().pendingAuth).toBeUndefined();
     expect(loadConfig().credentials?.username).toBe("ada");
   });

package/test/unit/sandbox.test.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { registerSandbox } from "../../src/commands/sandbox.js";
 import { api, APIError } from "../../src/lib/api.js";
 import { printJSON } from "../../src/lib/format.js";
+import { getProjectLink, resolveProjectId } from "../../src/lib/config.js";
 
 vi.mock("../../src/lib/api.js", () => {
   class APIError extends Error {
@@ -13,8 +14,8 @@ vi.mock("../../src/lib/api.js", () => {
 vi.mock("open", () => ({ default: vi.fn().mockResolvedValue(undefined) }));
 vi.mock("../../src/lib/config.js", () => ({
   resolveProjectId: vi.fn().mockResolvedValue("project-test"),
+  getProjectLink: vi.fn(() => ({ projectId: "project-test" })),
 }));
-vi.mock("../../src/lib/config.js", () => ({ resolveProjectId: vi.fn().mockResolvedValue("project-test") }));
 vi.mock("../../src/lib/format.js", () => ({ isJSONMode: () => true, printJSON: vi.fn() }));
 
 function create(args: string[]) {
@@ -46,6 +47,41 @@ describe("sandbox create timeout", () => {
 });
 
 
+describe("sandbox create without a project", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(api.post).mockResolvedValue({ id: "sandbox-test" });
+  });
+
+  it("an unlinked folder sends no project and leaves the choice to the platform", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create([]);
+    expect(resolveProjectId).not.toHaveBeenCalled();
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: undefined }));
+  });
+
+  it("a linked folder or --project still sends its project", async () => {
+    await create([]);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: "project-test" }));
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create(["--project", "web"]);
+    expect(resolveProjectId).toHaveBeenLastCalledWith("web");
+  });
+
+  it("an unlinked --volume still resolves a project, since a volume name lives in one", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create(["--volume", "data"]);
+    expect(resolveProjectId).toHaveBeenCalledWith(undefined);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: "project-test", volumeName: "data" }));
+  });
+
+  it("a platform that still wants a project gets the old message", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    vi.mocked(api.post).mockRejectedValueOnce(new APIError(400, "A project is required", "PROJECT_REQUIRED"));
+    await expect(create([])).rejects.toThrow("No project linked. Run `lizard init` or pass --project <id>.");
+  });
+});
+
 describe("unsupported sandbox commands", () => {
   it.each(["fork", "snapshot-fork", "logs"])(
     "rejects %s without making an API request", async (name) => {