@@ -151,6 +151,7 @@ describe("CLI lifecycle", () => {
     try {
       for (const [name, argv] of [
         ["open", [dir]],
+        ["open", ["--verbose", dir]],
         ["render", ["render"]],
       ] as const) {
         vi.doMock(`./commands/${name}.js`, () => ({
@@ -163,7 +164,8 @@ describe("CLI lifecycle", () => {
         vi.doUnmock(`./commands/${name}.js`);
         vi.resetModules();
       }
-      expect(run.mock.calls.map(([ctx]) => ctx.rawArgs)).toEqual([[dir], []]);
+      expect(run.mock.calls.map(([ctx]) => ctx.rawArgs)).toEqual([[dir], [dir], []]);
+      expect(process.argv.slice(2)).toEqual(["render"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
 
@@ -63,11 +63,7 @@ if (rootVersionRequested) {
 // Capture treats CWD as project data too: its early loader must use the same
 // allowlist/opt-out as output ancestors, before browser selection can observe it.
 const { applyDotEnv, CAPTURE_ENV_KEYS } = await import("./utils/dotEnv.js");
-// The root has no value-taking options: Citty skips flags up to the first
-// positional command, and stops subcommand selection at the -- separator.
-const separator = argv.indexOf("--");
-const commandArgs = separator < 0 ? argv : argv.slice(0, separator);
-const captureEnv = commandArgs.find((arg) => !arg.startsWith("-")) === "capture";
+const captureEnv = argv[commandWordIndex(argv)] === "capture";
 if (!captureEnv || process.env.HYPERFRAMES_NO_CAPTURE_DOTENV !== "1") {
   try {
     const { readFileSync } = await import("node:fs");
@@ -104,7 +100,7 @@ import {
   type CommandResult,
 } from "./utils/commandResult.js";
 import { registerRunningCli } from "./utils/runningCli.js";
-import { openShortcutArgv } from "./utils/projectShortcut.js";
+import { commandWordIndex, openShortcutArgv } from "./utils/projectShortcut.js";
 
 registerRunningCli();
 
@@ -185,11 +181,11 @@ const commandLoaders = {
 };
 
 // `hyperframes <dir>` is `hyperframes open <dir>`; every later read of the command sees `open`.
-const shortcutArgv = openShortcutArgv(argv, new Set(Object.keys(commandLoaders)));
-if (shortcutArgv !== argv) {
-  argv = [...shortcutArgv];
-  process.argv.splice(2, 0, "open");
-}
+process.argv = [
+  ...process.argv.slice(0, 2),
+  ...openShortcutArgv(argv, new Set(Object.keys(commandLoaders))),
+];
+argv = process.argv.slice(2);
 
 const subCommands = Object.fromEntries(
   Object.entries(commandLoaders).map(([name, load]) => [name, trackCommandFailures(load)]),
 
@@ -2,7 +2,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, describe, expect, it } from "vitest";
-import { openShortcutArgv } from "./projectShortcut.js";
+import { commandWordIndex, openShortcutArgv } from "./projectShortcut.js";
 
 const commands = new Set(["open", "render", "lint"]);
 const cwd = mkdtempSync(join(tmpdir(), "hf-shortcut-"));
@@ -24,14 +24,37 @@ describe("openShortcutArgv", () => {
     ]);
   });
 
+  it("finds the folder after root flags, like the command word", () => {
+    expect(openShortcutArgv(["--verbose", "my-video", "--json"], commands, cwd)).toEqual([
+      "--verbose",
+      "open",
+      "my-video",
+      "--json",
+    ]);
+  });
+
+  it("ignores a folder after the -- separator", () => {
+    expect(openShortcutArgv(["--", "my-video"], commands, cwd)).toEqual(["--", "my-video"]);
+  });
+
   it("lets a known command win over a folder with its name", () => {
     expect(openShortcutArgv(["render"], commands, cwd)).toEqual(["render"]);
   });
 
-  it.each([[[]], [["--help"]], [["--json", "my-video"]], [["notes.txt"]], [["nope"]]])(
-    "leaves %j alone",
-    (argv) => {
-      expect(openShortcutArgv(argv, commands, cwd)).toEqual(argv);
-    },
-  );
+  it.each([[[]], [["--help"]], [["notes.txt"]], [["nope"]]])("leaves %j alone", (argv) => {
+    expect(openShortcutArgv(argv, commands, cwd)).toEqual(argv);
+  });
+});
+
+describe("commandWordIndex", () => {
+  it.each([
+    [["render", "x"], 0],
+    [["--verbose", "render"], 1],
+    [["--verbose"], -1],
+    [["--", "render"], -1],
+    [["--verbose", "--", "render"], -1],
+    [[], -1],
+  ] as const)("%j -> %i", (argv, index) => {
+    expect(commandWordIndex(argv)).toBe(index);
+  });
 });
@@ -1,21 +1,31 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
 
+/**
+ * Where the root command word sits in argv, or -1. The root has no value-taking options: Citty
+ * skips flags up to the first positional and stops subcommand selection at the -- separator.
+ */
+export function commandWordIndex(argv: readonly string[]): number {
+  const end = argv.indexOf("--");
+  const index = argv.findIndex((arg) => !arg.startsWith("-"));
+  return end >= 0 && index >= end ? -1 : index;
+}
+
 /**
  * `hyperframes <dir>` is `hyperframes open <dir>`. A known command always wins, even over a
- * folder with its name; any other first word must be an existing directory to count as a project.
+ * folder with its name; any other command word must be an existing directory to count as a project.
  */
 export function openShortcutArgv(
   argv: readonly string[],
   commands: ReadonlySet<string>,
   cwd: string = process.cwd(),
 ): readonly string[] {
-  const first = argv[0];
-  if (!first || first.startsWith("-") || commands.has(first)) return argv;
+  const at = commandWordIndex(argv);
+  if (at < 0 || commands.has(argv[at]!)) return argv;
   try {
-    if (!statSync(resolve(cwd, first)).isDirectory()) return argv;
+    if (!statSync(resolve(cwd, argv[at]!)).isDirectory()) return argv;
   } catch {
     return argv;
   }
-  return ["open", ...argv];
+  return [...argv.slice(0, at), "open", ...argv.slice(at)];
 }