diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1fa0f0..846f6f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+### Added
+
+- Vite plugin `cedarPgDev()` (`@cedarjs/pg/vite-plus`): status panel on listen + shortcuts `d` (status) / `p` (Prisma or Drizzle Studio)
+- CLI: `cedarpg status` (human + `--json`) and `cedarpg studio` (`--prisma` / `--drizzle`)
+- Public `resolveDevStatus` / `formatDevStatus` for scripting
+
 ### Fixed
 
 - TEMPLATE `cloneWorkerDatabase`: default clone name is unique per call (`<worker>_<pid>_<time>`) so Jest `setupFiles` (module reload per file) no longer hits `database already exists` on `_c_<workerId>`
diff --git a/README.md b/README.md
index 1799e9b..30a6434 100644
--- a/README.md
+++ b/README.md
@@ -99,6 +99,8 @@ cedarpg run --mode=dev -- yarn tsx scripts/apiServer/dev.ts
 cedarpg run --mode=test -- vitest run
 cedarpg dispose --mode=test
 cedarpg print-url --mode=dev
+cedarpg status --mode=dev          # lease name, port, DATABASE_URL, env path
+cedarpg studio --mode=dev          # open Prisma or Drizzle Kit Studio (--prisma / --drizzle)
 cedarpg gc   # drop DBs whose worktree root is gone (uses ~/.cedarpg/registry)
 ```
 
@@ -170,9 +172,10 @@ Fallbacks when you cannot wrap with `run`: `loadDevEnv({ overwrite: true })` or
 ```ts
 // vite.config.ts
 import { defineConfig } from "vite-plus";
-import { cedarPgTasks } from "@cedarjs/pg/vite-plus";
+import { cedarPgTasks, cedarPgDev } from "@cedarjs/pg/vite-plus";
 
 export default defineConfig({
+  plugins: [cedarPgDev()],
   run: {
     tasks: {
       ...cedarPgTasks(),
@@ -191,6 +194,18 @@ export default defineConfig({
 });
 ```
 
+`cedarPgDev()` does **not** acquire — keep `dependsOn: ['db:acquire']`. On listen it prints a
+status panel (TTY, non-CI). Vite CLI shortcuts (`key` then Enter; also listed under `h`):
+
+| Key | Action                                                                 |
+| --- | ---------------------------------------------------------------------- |
+| `d` | Reprint cedar-pg status (name, port, `DATABASE_URL`, env file)         |
+| `p` | Open Prisma Studio or Drizzle Kit Studio with the lease `DATABASE_URL` |
+
+Options: `cedarPgDev({ mode, root, studio: "prisma" \| "drizzle" \| false })`. Studio auto-detects
+from the project (`prisma` preferred when both are present). Use `cedarpg status` / `cedarpg studio`
+for Nx and other non-Vite hosts.
+
 ## Vitest / Jest adapters
 
 ```ts
diff --git a/package.json b/package.json
index caf61ae..7670874 100644
--- a/package.json
+++ b/package.json
@@ -110,8 +110,17 @@
     "@types/node": "^22.15.0",
     "@types/pg": "^8.15.4",
     "typescript": "^5.8.3",
+    "vite": "^8.2.0",
     "vite-plus": "^0.2.4"
   },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
   "overrides": {
     "vite": "npm:@voidzero-dev/vite-plus-core@latest",
     "vitest": "4.1.9"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5eb41ba..e81bf89 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -220,6 +220,9 @@ importers:
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
+      vite:
+        specifier: ^8.2.0
+        version: 8.2.0(@types/node@22.20.1)
       vite-plus:
         specifier: ^0.2.4
         version: 0.2.7(@types/node@22.20.1)(typescript@5.9.3)(vite@8.2.0(@types/node@22.20.1))
diff --git a/src/adapters/studio.ts b/src/adapters/studio.ts
new file mode 100644
index 0000000..4103164
--- /dev/null
+++ b/src/adapters/studio.ts
@@ -0,0 +1,117 @@
+import { createRequire } from "node:module";
+import { spawn, type ChildProcess } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export type StudioKind = "prisma" | "drizzle";
+
+export type DetectStudioOptions = {
+  root: string;
+  /** Force a kind; `false` disables. Omit to auto-detect (prisma wins if both). */
+  prefer?: StudioKind | false;
+};
+
+export type DetectedStudio = {
+  kind: StudioKind;
+  /** Absolute path to the CLI entry, or null when falling back to npx. */
+  bin: string | null;
+  command: string;
+  args: string[];
+};
+
+type PkgJson = {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+};
+
+function readPackageJson(root: string): PkgJson | null {
+  const file = join(root, "package.json");
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8")) as PkgJson;
+  } catch {
+    return null;
+  }
+}
+
+function hasDep(pkg: PkgJson | null, name: string): boolean {
+  if (!pkg) return false;
+  return Boolean(
+    pkg.dependencies?.[name] || pkg.devDependencies?.[name] || pkg.optionalDependencies?.[name],
+  );
+}
+
+function tryResolveBin(root: string, packageName: string): string | null {
+  try {
+    const require = createRequire(pathToFileURL(join(root, "package.json")).href);
+    const pkgJsonPath = require.resolve(`${packageName}/package.json`);
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as {
+      bin?: string | Record<string, string>;
+    };
+    const binField = pkg.bin;
+    let rel: string | undefined;
+    if (typeof binField === "string") rel = binField;
+    else if (binField && typeof binField === "object") {
+      rel = binField[packageName] ?? Object.values(binField)[0];
+    }
+    if (!rel) return null;
+    const abs = join(dirname(pkgJsonPath), rel);
+    return existsSync(abs) ? abs : null;
+  } catch {
+    return null;
+  }
+}
+
+function prismaCommand(root: string): DetectedStudio {
+  const bin = tryResolveBin(root, "prisma");
+  if (bin) return { kind: "prisma", bin, command: bin, args: ["studio"] };
+  return { kind: "prisma", bin: null, command: "npx", args: ["prisma", "studio"] };
+}
+
+function drizzleCommand(root: string): DetectedStudio {
+  const bin = tryResolveBin(root, "drizzle-kit");
+  if (bin) return { kind: "drizzle", bin, command: bin, args: ["studio"] };
+  return { kind: "drizzle", bin: null, command: "npx", args: ["drizzle-kit", "studio"] };
+}
+
+function packagePresent(root: string, name: string): boolean {
+  return hasDep(readPackageJson(root), name) || Boolean(tryResolveBin(root, name));
+}
+
+/** Detect Prisma Studio or Drizzle Kit Studio from the project root. */
+export function detectStudio(options: DetectStudioOptions): DetectedStudio | null {
+  if (options.prefer === false) return null;
+
+  if (options.prefer === "prisma") return prismaCommand(options.root);
+  if (options.prefer === "drizzle") return drizzleCommand(options.root);
+
+  // Auto: prefer prisma when both present.
+  if (packagePresent(options.root, "prisma")) return prismaCommand(options.root);
+  if (packagePresent(options.root, "drizzle-kit")) return drizzleCommand(options.root);
+  return null;
+}
+
+export type OpenStudioOptions = {
+  root: string;
+  databaseUrl: string;
+  studio: DetectedStudio;
+};
+
+/**
+ * Spawn Studio detached with DATABASE_URL from the cedar-pg lease.
+ * Returns the child process; caller may ignore it.
+ */
+export function openStudio(options: OpenStudioOptions): ChildProcess {
+  const { root, databaseUrl, studio } = options;
+  const child = spawn(studio.command, studio.args, {
+    cwd: root,
+    env: { ...process.env, DATABASE_URL: databaseUrl },
+    detached: true,
+    stdio: "ignore",
+    shell: studio.bin === null,
+  });
+  child.unref();
+  return child;
+}
diff --git a/src/adapters/vite-dev-plugin.ts b/src/adapters/vite-dev-plugin.ts
new file mode 100644
index 0000000..50a816b
--- /dev/null
+++ b/src/adapters/vite-dev-plugin.ts
@@ -0,0 +1,99 @@
+import type { Plugin, ViteDevServer } from "vite";
+import { CLI_NAME } from "../core/constants.ts";
+import { formatDevStatus, resolveDevStatus } from "../core/status.ts";
+import type { DbMode } from "../core/naming.ts";
+import { detectStudio, openStudio, type StudioKind } from "./studio.ts";
+
+export type CedarPgDevOptions = {
+  mode?: DbMode;
+  root?: string;
+  /** Force Prisma/Drizzle Studio; `false` disables the `p` shortcut. Omit to auto-detect. */
+  studio?: StudioKind | false;
+};
+
+function shouldShowPanel(): boolean {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+
+function logStatus(server: ViteDevServer, options: CedarPgDevOptions): void {
+  const status = resolveDevStatus({ root: options.root, mode: options.mode ?? "dev" });
+  for (const line of formatDevStatus(status)) {
+    server.config.logger.info(line);
+  }
+}
+
+function tryOpenStudio(server: ViteDevServer, options: CedarPgDevOptions): void {
+  if (options.studio === false) {
+    server.config.logger.warn(`${CLI_NAME}: studio shortcut disabled`);
+    return;
+  }
+
+  const status = resolveDevStatus({ root: options.root, mode: options.mode ?? "dev" });
+  if (!status.ok) {
+    for (const line of formatDevStatus(status)) {
+      server.config.logger.warn(line);
+    }
+    return;
+  }
+
+  const studio = detectStudio({ root: status.root, prefer: options.studio });
+  if (!studio) {
+    server.config.logger.warn(
+      `${CLI_NAME}: no Prisma or Drizzle Studio found (install prisma or drizzle-kit)`,
+    );
+    return;
+  }
+
+  openStudio({ root: status.root, databaseUrl: status.databaseUrl, studio });
+  server.config.logger.info(
+    `${CLI_NAME}: opening ${studio.kind} studio (${studio.command} ${studio.args.join(" ")})`,
+  );
+}
+
+/**
+ * Vite / Vite+ plugin: print a cedar-pg status panel on listen and register
+ * CLI shortcuts (`d` status, `p` studio). Does **not** acquire — pair with
+ * `cedarPgTasks()` / `dependsOn: ['db:acquire']`.
+ */
+export function cedarPgDev(options: CedarPgDevOptions = {}): Plugin {
+  return {
+    name: "cedar-pg-dev",
+    configureServer(server) {
+      if (shouldShowPanel()) {
+        const print = (): void => {
+          logStatus(server, options);
+        };
+        if (server.httpServer) {
+          server.httpServer.once("listening", print);
+        } else {
+          // Middleware mode / late bind: still allow shortcuts; panel on demand via `d`.
+        }
+      }
+
+      const shortcuts = [
+        {
+          key: "d",
+          description: "show cedar-pg database status",
+          action(s: ViteDevServer) {
+            logStatus(s, options);
+          },
+        },
+      ];
+
+      if (options.studio !== false) {
+        shortcuts.push({
+          key: "p",
+          description: "open Prisma/Drizzle studio (cedar-pg DATABASE_URL)",
+          action(s: ViteDevServer) {
+            tryOpenStudio(s, options);
+          },
+        });
+      }
+
+      server.bindCLIShortcuts({
+        print: false,
+        customShortcuts: shortcuts,
+      });
+    },
+  };
+}
diff --git a/src/adapters/vite-plus.ts b/src/adapters/vite-plus.ts
index e8a4247..7452bbb 100644
--- a/src/adapters/vite-plus.ts
+++ b/src/adapters/vite-plus.ts
@@ -1,15 +1,17 @@
 /**
  * Consumer adapter for external Vite+ projects.
  *
- * Merge into `vite.config.ts` `run.tasks` so `vp run test` / `vp run dev`
- * depend on cedarpg acquire.
+ * - `cedarPgTasks()` — merge into `run.tasks` so `vp run test` / `vp run dev`
+ *   depend on cedarpg acquire.
+ * - `cedarPgDev()` — Vite plugin: status panel + `d` / `p` shortcuts (no acquire).
  *
  * @example
  * ```ts
  * import { defineConfig } from 'vite-plus'
- * import { cedarPgTasks } from '@cedarjs/pg/vite-plus'
+ * import { cedarPgTasks, cedarPgDev } from '@cedarjs/pg/vite-plus'
  *
  * export default defineConfig({
+ *   plugins: [cedarPgDev()],
  *   run: {
  *     tasks: {
  *       ...cedarPgTasks(),
@@ -47,3 +49,6 @@ export {
 
 export type CedarPgTaskDef = CedarPgLifecycleTarget;
 export type CedarPgTasksOptions = CedarPgLifecycleTargetsOptions;
+
+export { cedarPgDev } from "./vite-dev-plugin.ts";
+export type { CedarPgDevOptions } from "./vite-dev-plugin.ts";
diff --git a/src/cli.ts b/src/cli.ts
index a58e6b9..fef8057 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -4,7 +4,9 @@ import { CLI_NAME } from "./core/constants.ts";
 import { acquire, dispose, gc, urlFromLease } from "./core/lifecycle.ts";
 import { resolveWorktreeIdentity } from "./core/worktree.ts";
 import { readLease } from "./core/lease.ts";
+import { formatDevStatus, resolveDevStatus } from "./core/status.ts";
 import type { DbMode } from "./core/naming.ts";
+import { detectStudio, openStudio, type StudioKind } from "./adapters/studio.ts";
 
 function printHelp(): void {
   process.stdout.write(`${CLI_NAME}: worktree-isolated local Postgres (via autopg)
@@ -15,6 +17,8 @@ Usage:
   ${CLI_NAME} dispose [--mode=dev|test] [--root <path>]
   ${CLI_NAME} gc [--json]
   ${CLI_NAME} print-url [--mode=dev|test] [--root <path>]
+  ${CLI_NAME} status [--mode=dev|test] [--root <path>] [--json]
+  ${CLI_NAME} studio [--mode=dev|test] [--root <path>] [--prisma|--drizzle]
   ${CLI_NAME} --help
 
 Modes:
@@ -25,6 +29,10 @@ run:
   Acquire, set DATABASE_URL (+ TEST_DATABASE_URL in test) on the child, exec <cmd…>.
   --force sets CEDAR_PG_FORCE (escape hatch); child env overwrite is always on.
 
+status / studio:
+  Read-only lease inspection (no acquire). studio opens Prisma or Drizzle Kit Studio
+  with DATABASE_URL from the lease (auto-detect; --prisma / --drizzle to force).
+
 Env:
   AUTOPG_BIN       Path to autopg binary
   CEDAR_PG=0       Disable adapters that auto-acquire
@@ -45,6 +53,8 @@ type ParsedArgs = {
   printEnv?: boolean;
   force?: boolean;
   help?: boolean;
+  prisma?: boolean;
+  drizzle?: boolean;
   child?: string[];
 };
 
@@ -66,6 +76,8 @@ function parseArgs(argv: string[]): ParsedArgs {
     else if (a === "--json") out.json = true;
     else if (a === "--print-env") out.printEnv = true;
     else if (a === "--force") out.force = true;
+    else if (a === "--prisma") out.prisma = true;
+    else if (a === "--drizzle") out.drizzle = true;
     else if (a.startsWith("--mode=")) out.mode = parseMode(a.slice(7));
     else if (a === "--mode") out.mode = parseMode(flagArgs[++i]);
     else if (a.startsWith("--root=")) out.root = a.slice(7);
@@ -75,6 +87,15 @@ function parseArgs(argv: string[]): ParsedArgs {
   return out;
 }
 
+function studioPrefer(args: ParsedArgs): StudioKind | undefined {
+  if (args.prisma && args.drizzle) {
+    throw new Error("pass only one of --prisma or --drizzle");
+  }
+  if (args.prisma) return "prisma";
+  if (args.drizzle) return "drizzle";
+  return undefined;
+}
+
 function runChild(command: string[], env: NodeJS.ProcessEnv): Promise<number> {
   const [file, ...args] = command;
   if (!file) {
@@ -204,6 +225,67 @@ async function main(): Promise<number> {
       return 0;
     }
 
+    if (args.cmd === "status") {
+      const mode = args.mode ?? "dev";
+      const status = resolveDevStatus({ root: args.root, mode });
+      if (args.json) {
+        if (!status.ok) {
+          process.stdout.write(
+            `${JSON.stringify({ ok: false, reason: status.reason, mode: status.mode, root: status.root }, null, 2)}\n`,
+          );
+          return 2;
+        }
+        process.stdout.write(
+          `${JSON.stringify(
+            {
+              ok: true,
+              mode: status.mode,
+              root: status.root,
+              databaseUrl: status.databaseUrl,
+              envPath: status.envPath,
+              databaseName: status.lease.databaseName,
+              roleName: status.lease.roleName,
+              repoSlug: status.lease.repoSlug,
+              worktreeSlug: status.lease.worktreeSlug,
+              port: status.lease.port,
+              createdAt: status.lease.createdAt,
+            },
+            null,
+            2,
+          )}\n`,
+        );
+        return 0;
+      }
+      for (const line of formatDevStatus(status)) {
+        process.stdout.write(`${line}\n`);
+      }
+      return status.ok ? 0 : 2;
+    }
+
+    if (args.cmd === "studio") {
+      const mode = args.mode ?? "dev";
+      const prefer = studioPrefer(args);
+      const status = resolveDevStatus({ root: args.root, mode });
+      if (!status.ok) {
+        for (const line of formatDevStatus(status)) {
+          process.stderr.write(`${line}\n`);
+        }
+        return 2;
+      }
+      const studio = detectStudio({ root: status.root, prefer });
+      if (!studio) {
+        process.stderr.write(
+          `${CLI_NAME}: no Prisma or Drizzle Studio found (install prisma or drizzle-kit)\n`,
+        );
+        return 1;
+      }
+      openStudio({ root: status.root, databaseUrl: status.databaseUrl, studio });
+      process.stdout.write(
+        `${CLI_NAME}: opening ${studio.kind} studio (${studio.command} ${studio.args.join(" ")})\n`,
+      );
+      return 0;
+    }
+
     process.stderr.write(`${CLI_NAME}: unknown command ${args.cmd}\n`);
     printHelp();
     return 64;
diff --git a/src/core/status.ts b/src/core/status.ts
new file mode 100644
index 0000000..e571b95
--- /dev/null
+++ b/src/core/status.ts
@@ -0,0 +1,63 @@
+import { CLI_NAME } from "./constants.ts";
+import { envFilePath, readLease, type Lease } from "./lease.ts";
+import { urlFromLease } from "./lifecycle.ts";
+import type { DbMode } from "./naming.ts";
+import { resolveWorktreeIdentity } from "./worktree.ts";
+
+export type ResolveDevStatusOptions = {
+  root?: string;
+  mode?: DbMode;
+};
+
+export type DevStatusOk = {
+  ok: true;
+  mode: DbMode;
+  root: string;
+  lease: Lease;
+  databaseUrl: string;
+  envPath: string;
+};
+
+export type DevStatusMissing = {
+  ok: false;
+  reason: "no-lease";
+  mode: DbMode;
+  root: string;
+};
+
+export type DevStatus = DevStatusOk | DevStatusMissing;
+
+/** Read-only lease snapshot for CLI / Vite panel (no acquire, no host). */
+export function resolveDevStatus(options: ResolveDevStatusOptions = {}): DevStatus {
+  const mode = options.mode ?? "dev";
+  const { root } = resolveWorktreeIdentity(options.root);
+  const lease = readLease(root, mode);
+  if (!lease) {
+    return { ok: false, reason: "no-lease", mode, root };
+  }
+  return {
+    ok: true,
+    mode,
+    root,
+    lease,
+    databaseUrl: urlFromLease(lease),
+    envPath: envFilePath(root, mode),
+  };
+}
+
+/** Human-readable lines for the Vite panel / `cedarpg status`. */
+export function formatDevStatus(status: DevStatus): string[] {
+  if (!status.ok) {
+    return [
+      `${CLI_NAME}: no ${status.mode} lease at ${status.root}`,
+      `  run \`${CLI_NAME} acquire --mode=${status.mode}\` (or depend on db:acquire)`,
+    ];
+  }
+  const { lease, databaseUrl, envPath } = status;
+  return [
+    `${CLI_NAME}: ${lease.databaseName} (${lease.repoSlug}/${lease.worktreeSlug} ${lease.mode})`,
+    `  port          ${lease.port}`,
+    `  DATABASE_URL  ${databaseUrl}`,
+    `  env           ${envPath}`,
+  ];
+}
diff --git a/src/index.ts b/src/index.ts
index 40acfa8..3234ecf 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -41,6 +41,15 @@ export type { CreateAcquireTaskOptions, AcquireTaskContext } from "./adapters/ac
 export { parseLease, readLease, isOrphanLease, envFilePath } from "./core/lease.ts";
 export type { Lease } from "./core/lease.ts";
 
+/** Read-only status snapshot for CLI / scripting (Vite panel uses the same helpers). */
+export { resolveDevStatus, formatDevStatus } from "./core/status.ts";
+export type {
+  ResolveDevStatusOptions,
+  DevStatus,
+  DevStatusOk,
+  DevStatusMissing,
+} from "./core/status.ts";
+
 export {
   resolveAcquireSkip,
   applyDatabaseUrlEnv,
diff --git a/tests/status.test.ts b/tests/status.test.ts
new file mode 100644
index 0000000..a4e61c4
--- /dev/null
+++ b/tests/status.test.ts
@@ -0,0 +1,67 @@
+import { expect, test } from "vite-plus/test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeLease, type Lease } from "../src/core/lease.ts";
+import { formatDevStatus, resolveDevStatus } from "../src/core/status.ts";
+
+function makeLease(partial: Partial<Lease> & Pick<Lease, "root" | "databaseName" | "mode">): Lease {
+  return {
+    schemaVersion: 1,
+    repoSlug: "cedar",
+    worktreeSlug: "main",
+    pathHash: "abcd1234",
+    roleName: `${partial.databaseName}_role`,
+    port: 54321,
+    pid: 1,
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...partial,
+  };
+}
+
+test("resolveDevStatus returns no-lease when missing", () => {
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-status-"));
+  try {
+    const status = resolveDevStatus({ root, mode: "dev" });
+    expect(status.ok).toBe(false);
+    if (status.ok) return;
+    expect(status.reason).toBe("no-lease");
+    expect(status.mode).toBe("dev");
+    expect(status.root).toBe(root);
+    const lines = formatDevStatus(status);
+    expect(lines.some((l) => l.includes("no dev lease"))).toBe(true);
+    expect(lines.some((l) => l.includes("acquire"))).toBe(true);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveDevStatus + formatDevStatus include url and env path", () => {
+  const registry = mkdtempSync(join(tmpdir(), "cedarpg-status-reg-"));
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-status-wt-"));
+  const prev = process.env.CEDAR_PG_REGISTRY_DIR;
+  process.env.CEDAR_PG_REGISTRY_DIR = registry;
+  try {
+    const lease = makeLease({
+      root,
+      mode: "dev",
+      databaseName: "cpg_cedar_main_dev_abcd1234",
+    });
+    writeLease(lease);
+    const status = resolveDevStatus({ root, mode: "dev" });
+    expect(status.ok).toBe(true);
+    if (!status.ok) return;
+    expect(status.databaseUrl).toContain("cpg_cedar_main_dev_abcd1234");
+    expect(status.databaseUrl).toContain(":54321/");
+    expect(status.envPath).toBe(join(root, ".cedarpg", "dev.env"));
+    const lines = formatDevStatus(status);
+    expect(lines[0]).toContain("cpg_cedar_main_dev_abcd1234");
+    expect(lines.some((l) => l.includes("DATABASE_URL"))).toBe(true);
+    expect(lines.some((l) => l.includes("dev.env"))).toBe(true);
+  } finally {
+    if (prev === undefined) delete process.env.CEDAR_PG_REGISTRY_DIR;
+    else process.env.CEDAR_PG_REGISTRY_DIR = prev;
+    rmSync(registry, { recursive: true, force: true });
+    rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/tests/studio.test.ts b/tests/studio.test.ts
new file mode 100644
index 0000000..5f2221e
--- /dev/null
+++ b/tests/studio.test.ts
@@ -0,0 +1,81 @@
+import { expect, test } from "vite-plus/test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectStudio } from "../src/adapters/studio.ts";
+
+test("detectStudio returns null when no ORM packages", () => {
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-studio-"));
+  try {
+    writeFileSync(join(root, "package.json"), JSON.stringify({ name: "app", version: "1.0.0" }));
+    expect(detectStudio({ root })).toBeNull();
+    expect(detectStudio({ root, prefer: false })).toBeNull();
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("detectStudio finds prisma from package.json", () => {
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-studio-"));
+  try {
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({
+        name: "app",
+        version: "1.0.0",
+        devDependencies: { prisma: "^6.0.0" },
+      }),
+    );
+    const studio = detectStudio({ root });
+    expect(studio?.kind).toBe("prisma");
+    expect(studio?.args).toContain("studio");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("detectStudio finds drizzle-kit and prefers prisma when both", () => {
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-studio-"));
+  try {
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({
+        name: "app",
+        version: "1.0.0",
+        devDependencies: { prisma: "^6.0.0", "drizzle-kit": "^0.30.0" },
+      }),
+    );
+    expect(detectStudio({ root })?.kind).toBe("prisma");
+    expect(detectStudio({ root, prefer: "drizzle" })?.kind).toBe("drizzle");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("detectStudio resolves local bin when installed", () => {
+  const root = mkdtempSync(join(tmpdir(), "cedarpg-studio-"));
+  try {
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({
+        name: "app",
+        version: "1.0.0",
+        dependencies: { prisma: "1.0.0" },
+      }),
+    );
+    const pkgDir = join(root, "node_modules", "prisma");
+    mkdirSync(pkgDir, { recursive: true });
+    writeFileSync(
+      join(pkgDir, "package.json"),
+      JSON.stringify({ name: "prisma", version: "1.0.0", bin: { prisma: "build/index.js" } }),
+    );
+    mkdirSync(join(pkgDir, "build"), { recursive: true });
+    writeFileSync(join(pkgDir, "build", "index.js"), "#!/usr/bin/env node\n");
+    const studio = detectStudio({ root });
+    expect(studio?.kind).toBe("prisma");
+    expect(studio?.bin).toContain(join("node_modules", "prisma", "build", "index.js"));
+    expect(studio?.command).toBe(studio?.bin);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/tests/vite-dev-plugin.test.ts b/tests/vite-dev-plugin.test.ts
new file mode 100644
index 0000000..88cb312
--- /dev/null
+++ b/tests/vite-dev-plugin.test.ts
@@ -0,0 +1,56 @@
+import { expect, test, vi } from "vite-plus/test";
+import { EventEmitter } from "node:events";
+import type { ViteDevServer } from "vite";
+import { cedarPgDev } from "../src/adapters/vite-plus.ts";
+
+function invokeConfigureServer(
+  plugin: ReturnType<typeof cedarPgDev>,
+  server: Pick<ViteDevServer, "httpServer" | "config" | "bindCLIShortcuts">,
+): void {
+  const hook = plugin.configureServer;
+  if (typeof hook !== "function") {
+    throw new Error("expected configureServer function");
+  }
+  (hook as unknown as (s: typeof server) => void)(server);
+}
+
+test("cedarPgDev registers d and p shortcuts without printing help", () => {
+  const bindCLIShortcuts = vi.fn();
+  const info = vi.fn();
+  const warn = vi.fn();
+  const httpServer = new EventEmitter();
+
+  const server = {
+    httpServer,
+    config: { logger: { info, warn } },
+    bindCLIShortcuts,
+  };
+
+  const plugin = cedarPgDev();
+  expect(plugin.name).toBe("cedar-pg-dev");
+  invokeConfigureServer(plugin, server as never);
+
+  expect(bindCLIShortcuts).toHaveBeenCalledWith(
+    expect.objectContaining({
+      print: false,
+      customShortcuts: expect.any(Array),
+    }),
+  );
+  const shortcuts = bindCLIShortcuts.mock.calls[0]![0].customShortcuts as Array<{
+    key: string;
+    description: string;
+  }>;
+  expect(shortcuts.map((s) => s.key).sort()).toEqual(["d", "p"]);
+});
+
+test("cedarPgDev omits p shortcut when studio is false", () => {
+  const bindCLIShortcuts = vi.fn();
+  const server = {
+    httpServer: null,
+    config: { logger: { info: vi.fn(), warn: vi.fn() } },
+    bindCLIShortcuts,
+  };
+  invokeConfigureServer(cedarPgDev({ studio: false }), server as never);
+  const shortcuts = bindCLIShortcuts.mock.calls[0]![0].customShortcuts as Array<{ key: string }>;
+  expect(shortcuts.map((s) => s.key)).toEqual(["d"]);
+});
diff --git a/tests/vite-plus.test.ts b/tests/vite-plus.test.ts
index 9f0bb3c..cb754f8 100644
--- a/tests/vite-plus.test.ts
+++ b/tests/vite-plus.test.ts
@@ -1,6 +1,7 @@
 import { expect, test } from "vite-plus/test";
 import {
   cedarPgTasks,
+  cedarPgDev,
   CEDAR_PG_TASK_ACQUIRE_DEV,
   CEDAR_PG_TASK_ACQUIRE_TEST,
 } from "../src/adapters/vite-plus.ts";
@@ -16,3 +17,8 @@ test("cedarPgTasks respects custom bin", () => {
   const tasks = cedarPgTasks({ bin: "./bin/cedarpg" });
   expect(tasks[CEDAR_PG_TASK_ACQUIRE_DEV]?.command.startsWith("./bin/cedarpg")).toBe(true);
 });
+
+test("cedarPgDev is exported from vite-plus", () => {
+  expect(typeof cedarPgDev).toBe("function");
+  expect(cedarPgDev().name).toBe("cedar-pg-dev");
+});