forgeos 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/forge/cli/parse.ts

@@ -14,9 +14,11 @@ import type { LiveSubcommand } from "./live.ts";
 import type { ForgeAiProvider } from "../runtime/ai/types.ts";
 import type { NewPackageManager, NewTemplateName } from "./new.ts";
 import type { SelfHostSubcommand } from "./self-host.ts";
+import type { DocsSubcommand } from "./docs.ts";
 import type { AgentContractSubcommand } from "./agent-contract.ts";
 import type { AuthSubcommand } from "./auth.ts";
 import type { RlsSubcommand } from "./rls.ts";
+import type { SecuritySubcommand } from "./security.ts";
 import type { DepsSubcommand } from "./deps.ts";
 import type { ReleaseAction, ReleaseArea } from "./release.ts";
 import type { MakeCommandOptions, MakePrimitive } from "../make/types.ts";
@@ -46,8 +48,12 @@ import type {
   UiVideoMode,
 } from "../ui/types.ts";
 import type { ForgeDoOptions } from "../intent/types.ts";
+import type { BenchCommandOptions, BenchSubcommand } from "../bench.ts";
+import type { BrownfieldImportCommandOptions } from "../brownfield-import/types.ts";
+import type { CairCommandOptions, CairSubcommand } from "../cair/types.ts";
 
 export type ForgeCommand =
+  | { kind: "version"; json: boolean }
   | {
       kind: "new";
       name: string;
@@ -89,6 +95,15 @@ export type ForgeCommand =
       postgresVersion: string;
       runtimePort: number;
       webPort: number;
+      preparedOnly?: boolean;
+      workspaceRoot: string;
+    }
+  | {
+      kind: "docs";
+      subcommand: DocsSubcommand;
+      json: boolean;
+      build: boolean;
+      installVenv: boolean;
       workspaceRoot: string;
     }
   | {
@@ -97,8 +112,17 @@ export type ForgeCommand =
       json: boolean;
       workspaceRoot: string;
     }
-  | { kind: "doctor"; target?: "project" | "windows"; json: boolean; workspaceRoot: string }
+  | { kind: "doctor"; target?: "project" | "windows" | "agent"; agentTarget?: AgentAdapterTarget; json: boolean; workspaceRoot: string }
   | { kind: "setup"; target: "windows"; json: boolean; yes: boolean; workspaceRoot: string }
+  | {
+      kind: "security";
+      subcommand: SecuritySubcommand;
+      db: DbAdapterKind;
+      databaseUrl?: string;
+      json: boolean;
+      runTests: boolean;
+      workspaceRoot: string;
+    }
   | {
       kind: "auth";
       subcommand: AuthSubcommand;
@@ -141,6 +165,7 @@ export type ForgeCommand =
       json: boolean;
       allowDirty: boolean;
       allowPublicSourcemaps: boolean;
+      allowMissingLocalRelease?: boolean;
       workspaceRoot: string;
     }
   | { kind: "make"; options: MakeCommandOptions }
@@ -150,12 +175,59 @@ export type ForgeCommand =
   | { kind: "test"; options: TestCommandOptions }
   | { kind: "repair"; options: RepairCommandOptions }
   | { kind: "do"; options: ForgeDoOptions }
+  | { kind: "bench"; options: BenchCommandOptions }
+  | { kind: "cair"; options: CairCommandOptions }
   | { kind: "agent"; options: AgentCommandOptions }
+  | { kind: "mcp"; subcommand: "serve"; workspaceRoot: string }
   | { kind: "review"; options: ReviewCommandOptions }
   | { kind: "ui"; options: UiCommandOptions }
-  | { kind: "generate"; check: boolean; dryRun: boolean; json: boolean; concurrency: number }
+  | { kind: "manifest"; subcommand: "validate" | "import"; path: string; json: boolean; workspaceRoot: string }
+  | { kind: "import"; options: BrownfieldImportCommandOptions }
+  | { kind: "delta"; subcommand: "status" | "repair"; json: boolean; workspaceRoot: string; dryRun: boolean; yes: boolean; verbose: boolean }
+  | { kind: "status"; json: boolean; workspaceRoot: string }
+  | { kind: "changed"; json: boolean; authoredOnly: boolean; workspaceRoot: string }
+  | { kind: "diff"; target: "authored" | "generated" | "full"; json: boolean; workspaceRoot: string }
+  | { kind: "handoff"; json: boolean; workspaceRoot: string }
+  | {
+      kind: "studio";
+      subcommand: "attach" | "snapshot" | "watch" | "open" | "doctor" | "bridge" | "codex-server";
+      path?: string;
+      previewUrl?: string;
+      previewPort?: number;
+      studioUrl?: string;
+      intervalMs?: number;
+      once: boolean;
+      workspaceId?: string;
+      tenantId?: string;
+      userId?: string;
+      role?: string;
+      targets: string[];
+      install?: boolean;
+      start?: boolean;
+      bridge?: boolean;
+      writeSchemas?: boolean;
+      probeAppServer?: boolean;
+      json: boolean;
+      dryRun: boolean;
+      force: boolean;
+      workspaceRoot: string;
+    }
+  | { kind: "timeline"; target?: string; kindFilter?: string; sessionId?: string; limit?: number; json: boolean; rebuild: boolean; forAgent: boolean; workspaceRoot: string }
+  | { kind: "explain"; thing: string; json: boolean; workspaceRoot: string }
+  | {
+      kind: "session";
+      subcommand: "list" | "show" | "rename" | "merge" | "split" | "detach";
+      sessionId?: string;
+      sourceSessionId?: string;
+      operationId?: string;
+      title?: string;
+      limit?: number;
+      json: boolean;
+      workspaceRoot: string;
+    }
+  | { kind: "generate"; check: boolean; dryRun: boolean; json: boolean; concurrency: number; workspaceRoot: string }
   | { kind: "add"; alias: string; options: AddOptions & { workspaceRoot: string } }
-  | { kind: "inspect"; target: InspectTarget; json: boolean; dryRun: boolean }
+  | { kind: "inspect"; target: InspectTarget; json: boolean; dryRun: boolean; full: boolean; brief: boolean }
   | { kind: "check"; json: boolean; dryRun: boolean; strictSecrets: boolean }
   | { kind: "verify"; options: VerifyOptions }
   | { kind: "run"; name?: string; list: boolean; json: boolean; mock: boolean; userId?: string; tenantId?: string; role?: string; envFile?: string; workspaceRoot: string; queryMode?: boolean; args?: unknown }
@@ -168,7 +240,7 @@ export type ForgeCommand =
       once: boolean;
       watch: boolean;
       json: boolean;
-      db: "pglite" | "postgres" | "none";
+      db: "memory" | "pglite" | "postgres" | "none";
       databaseUrl?: string;
       worker: boolean;
       withWeb: boolean;
@@ -178,6 +250,7 @@ export type ForgeCommand =
       webPort?: number;
       telemetry: string[];
       envFile?: string;
+      skipStartupConsole: boolean;
       workspaceRoot: string;
     }
   | {
@@ -284,6 +357,11 @@ export type ForgeCommand =
       model?: string;
       prompt?: string;
       mock: boolean;
+      modelLevel: boolean;
+      live: boolean;
+      traceId?: string;
+      db?: DbAdapterKind;
+      databaseUrl?: string;
       workspaceRoot: string;
     };
 
@@ -294,17 +372,21 @@ export interface ParsedCli {
 }
 
 export const TOP_LEVEL_COMMANDS = [
+  "version",
   "new",
   "build",
   "serve",
   "worker",
   "self-host",
+  "docs",
   "agent-contract",
   "agent",
+  "mcp",
   "review",
   "ui",
   "doctor",
   "setup",
+  "security",
   "auth",
   "rls",
   "deps",
@@ -316,6 +398,19 @@ export const TOP_LEVEL_COMMANDS = [
   "test",
   "repair",
   "do",
+  "bench",
+  "cair",
+  "delta",
+  "session",
+  "timeline",
+  "explain",
+  "manifest",
+  "import",
+  "status",
+  "changed",
+  "diff",
+  "handoff",
+  "studio",
   "generate",
   "add",
   "inspect",
@@ -352,6 +447,7 @@ export const INSPECT_TARGETS: InspectTarget[] = [
   "ai",
   "queries",
   "api",
+  "external",
   "client",
   "frontend",
   "auth",
@@ -367,9 +463,15 @@ export const INSPECT_TARGETS: InspectTarget[] = [
   "test-graph",
   "test-plans",
   "agent-contract",
+  "agent-tools",
   "agent-adapters",
   "capability-map",
+  "summary",
+  "schema",
+  "drift",
+  "handoff",
   "framework",
+  "imported",
   "ui",
   "ui-scenarios",
   "ui-routes",
@@ -378,7 +480,7 @@ export const INSPECT_TARGETS: InspectTarget[] = [
   "map",
 ];
 
-const NEW_TEMPLATES: NewTemplateName[] = ["b2b-support-web", "minimal-web"];
+const NEW_TEMPLATES: NewTemplateName[] = ["agent-workroom", "b2b-support-web", "minimal-web"];
 const NEW_PACKAGE_MANAGERS: NewPackageManager[] = ["bun", "npm", "pnpm", "yarn"];
 const SELF_HOST_SUBCOMMANDS: SelfHostSubcommand[] = ["compose", "env", "check", "clean"];
 const AGENT_CONTRACT_SUBCOMMANDS: AgentContractSubcommand[] = [
@@ -392,8 +494,10 @@ const AUTH_SUBCOMMANDS: AuthSubcommand[] = [
   "decode",
   "test-token",
   "jwks",
+  "prove",
 ];
-const RLS_SUBCOMMANDS: RlsSubcommand[] = ["generate", "check", "apply", "test"];
+const SECURITY_SUBCOMMANDS: SecuritySubcommand[] = ["prove"];
+const RLS_SUBCOMMANDS: RlsSubcommand[] = ["generate", "check", "apply", "test", "mutate-test"];
 const DEPS_SUBCOMMANDS: DepsSubcommand[] = [
   "outdated",
   "inspect",
@@ -430,6 +534,7 @@ const MAKE_PRIMITIVES: MakePrimitive[] = [
   "component",
   "page",
   "ui",
+  "ai-chat",
   "resource",
   "apply",
   "rollback",
@@ -484,10 +589,18 @@ const AGENT_SUBCOMMANDS: AgentSubcommand[] = [
   "export",
   "check",
   "doctor",
+  "onboard",
   "print-context",
   "clean",
+  "prepare",
+  "hooks",
+  "install",
+  "ingest",
+  "context",
+  "memory",
+  "timeline",
 ];
-const REVIEW_SUBCOMMANDS: ReviewSubcommand[] = ["inspect", "list", "explain"];
+const REVIEW_SUBCOMMANDS: ReviewSubcommand[] = ["run", "inspect", "list", "explain"];
 const REVIEW_MODES: ReviewMode[] = ["quick", "standard", "strict"];
 const REVIEW_FAIL_ON: ReviewFailOn[] = ["warning", "error", "blocking"];
 const REVIEW_CATEGORIES: ReviewFindingCategory[] = [
@@ -518,6 +631,18 @@ const UI_BROWSERS: UiBrowserName[] = ["chromium", "firefox", "webkit"];
 const UI_TRACE_MODES: UiTraceMode[] = ["on", "off", "retain-on-failure"];
 const UI_SCREENSHOT_MODES: UiScreenshotMode[] = ["on", "off", "only-on-failure"];
 const UI_VIDEO_MODES: UiVideoMode[] = ["on", "off", "retain-on-failure"];
+const AI_SUBCOMMANDS: AiSubcommand[] = [
+  "providers",
+  "check",
+  "test",
+  "models",
+  "tools",
+  "agents",
+  "redteam",
+  "trace",
+];
+const BENCH_SUBCOMMANDS: BenchSubcommand[] = ["compiler"];
+const CAIR_SUBCOMMANDS: CairSubcommand[] = ["snapshot", "query", "action"];
 
 function parseFlag(args: string[], flag: string): boolean {
   return args.includes(flag);
@@ -542,13 +667,17 @@ function parseOptionValues(args: string[], flag: string): string[] {
   return values;
 }
 
-function parseDbKind(value: string | undefined): "pglite" | "postgres" | "none" {
-  if (value === "postgres" || value === "none") {
+function parseDbKind(value: string | undefined): "memory" | "pglite" | "postgres" | "none" {
+  if (value === "memory" || value === "postgres" || value === "none") {
     return value;
   }
   return "pglite";
 }
 
+function parsePersistentDbKind(value: string | undefined): DbAdapterKind {
+  return parseDbKind(value) === "postgres" ? "postgres" : "pglite";
+}
+
 function parseAdapterKind(value: string | undefined): DbAdapterKind {
   if (value === "postgres" || value === "memory") {
     return value;
@@ -566,7 +695,10 @@ function parseSandboxBackend(value: string | undefined): SandboxBackend {
 function parseAddOptions(
   args: string[],
   workspaceRoot: string,
+  mode: AddOptions["mode"] = "auto",
 ): AddOptions & { workspaceRoot: string } {
+  const frontend = parseFlag(args, "--frontend");
+  const backend = parseFlag(args, "--backend");
   return {
     workspaceRoot,
     json: parseFlag(args, "--json"),
@@ -576,6 +708,9 @@ function parseAddOptions(
       parseOptionValue(args, "--sandbox-backend"),
     ),
     allowScripts: parseFlag(args, "--allow-scripts"),
+    mode,
+    installWorkspace: parseOptionValue(args, "--workspace"),
+    packageTarget: frontend && !backend ? "frontend" : backend ? "backend" : undefined,
   };
 }
 
@@ -655,6 +790,14 @@ export function parseCli(argv: string[]): ParsedCli {
   const positional = argv.filter((arg) => !arg.startsWith("-"));
   const workspaceRoot = process.cwd().replace(/\\/g, "/");
 
+  if (parseFlag(argv, "--version") || parseFlag(argv, "-v")) {
+    return {
+      command: { kind: "version", json: parseFlag(argv, "--json") },
+      workspaceRoot,
+      errors,
+    };
+  }
+
   if (positional.length === 0) {
     errors.push(
       `missing command; expected ${TOP_LEVEL_COMMANDS.join(", ")}`,
@@ -794,6 +937,26 @@ export function parseCli(argv: string[]): ParsedCli {
           postgresVersion: parseOptionValue(argv, "--postgres-version") ?? "16",
           runtimePort: Math.floor(runtimePort),
           webPort: Math.floor(webPort),
+          preparedOnly: parseFlag(argv, "--prepared-only"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "docs": {
+      const subcommand = rest[0] as DocsSubcommand | undefined;
+      if (subcommand !== "check") {
+        errors.push("forge docs requires subcommand: check");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "docs",
+          subcommand,
+          json: parseFlag(argv, "--json"),
+          build: parseFlag(argv, "--build"),
+          installVenv: parseFlag(argv, "--install-venv"),
           workspaceRoot,
         },
         workspaceRoot,
@@ -820,12 +983,38 @@ export function parseCli(argv: string[]): ParsedCli {
     case "agent": {
       const subcommand = rest[0] as AgentSubcommand | undefined;
       if (!subcommand || !AGENT_SUBCOMMANDS.includes(subcommand)) {
-        errors.push("forge agent requires subcommand: list-targets, export, check, doctor, print-context, or clean");
+        errors.push("forge agent requires subcommand: list-targets, export, check, doctor, onboard, print-context, clean, prepare, hooks, install, ingest, context, memory, or timeline");
         return { command: null, workspaceRoot, errors };
       }
+      const inputRaw = parseOptionValue(argv, "--input");
+      let input: unknown;
+      if (inputRaw !== undefined) {
+        try {
+          input = JSON.parse(inputRaw);
+        } catch {
+          errors.push("--input must be valid JSON");
+        }
+      }
+      const limitRaw = parseOptionValue(argv, "--limit");
+      const limit = limitRaw ? Number(limitRaw) : undefined;
+      const pollIntervalRaw = parseOptionValue(argv, "--poll-interval");
+      const pollIntervalMs = pollIntervalRaw ? Number(pollIntervalRaw) : undefined;
+      if (limitRaw !== undefined && (!Number.isFinite(limit) || limit! < 1)) {
+        errors.push("--limit must be a number >= 1");
+      }
+      if (
+        pollIntervalRaw !== undefined &&
+        (!Number.isFinite(pollIntervalMs) || pollIntervalMs! < 100)
+      ) {
+        errors.push("--poll-interval must be a number >= 100");
+      }
       const target =
         (parseOptionValue(argv, "--target") as AgentAdapterTarget | undefined) ??
-        (subcommand === "export" || subcommand === "clean" ? "generic" : "generic");
+        (subcommand === "install" || subcommand === "ingest" ? rest[1] : undefined) ??
+        (subcommand === "hooks" ? rest[2] : undefined) ??
+        (subcommand === "timeline" ? rest[1] : undefined) ??
+        (subcommand === "timeline" ? "all" : undefined) ??
+        (subcommand === "hooks" || subcommand === "onboard" ? "codex" : "generic");
       return {
         command: {
           kind: "agent",
@@ -839,12 +1028,37 @@ export function parseCli(argv: string[]): ParsedCli {
             preserveUserSections: !parseFlag(argv, "--no-preserve-user-sections"),
             skills: !parseFlag(argv, "--no-skills"),
             rules: !parseFlag(argv, "--no-rules"),
+            eventName: parseOptionValue(argv, "--event"),
+            hookAction: subcommand === "hooks" ? rest[1] : undefined,
+            input,
+            entry: parseOptionValue(argv, "--entry") ?? (subcommand === "context" && rest[1] !== "--current" ? rest[1] : undefined),
+            current: parseFlag(argv, "--current"),
+            limit: limit ? Math.floor(limit) : undefined,
+            watch: parseFlag(argv, "--watch"),
+            file: parseOptionValue(argv, "--file"),
+            pollIntervalMs: pollIntervalMs ? Math.floor(pollIntervalMs) : undefined,
           },
         },
         workspaceRoot,
         errors,
       };
     }
+    case "mcp": {
+      const subcommand = rest[0];
+      if (subcommand !== "serve") {
+        errors.push("forge mcp requires subcommand: serve");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "mcp",
+          subcommand,
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
     case "review": {
       const requested = rest[0] as ReviewSubcommand | undefined;
       const subcommand =
@@ -867,6 +1081,7 @@ export function parseCli(argv: string[]): ParsedCli {
             json: parseFlag(argv, "--json"),
             md: parseFlag(argv, "--md"),
             sarif: parseFlag(argv, "--sarif"),
+            full: parseFlag(argv, "--full"),
             write: positionalWrite || parseFlag(argv, "--write"),
             changed: parseFlag(argv, "--changed") || noSourceFlag,
             staged: parseFlag(argv, "--staged"),
@@ -937,14 +1152,17 @@ export function parseCli(argv: string[]): ParsedCli {
       };
     }
     case "doctor":
-      if (rest[0] && rest[0] !== "windows") {
-        errors.push("forge doctor supports subcommand: windows");
+      if (rest[0] && rest[0] !== "windows" && rest[0] !== "agent") {
+        errors.push("forge doctor supports subcommand: windows or agent");
         return { command: null, workspaceRoot, errors };
       }
       return {
         command: {
           kind: "doctor",
-          target: rest[0] === "windows" ? "windows" : "project",
+          target: rest[0] === "windows" ? "windows" : rest[0] === "agent" ? "agent" : "project",
+          agentTarget: rest[0] === "agent"
+            ? (parseOptionValue(argv, "--target") as AgentAdapterTarget | undefined) ?? (rest[1] as AgentAdapterTarget | undefined) ?? "codex"
+            : undefined,
           json: parseFlag(argv, "--json"),
           workspaceRoot,
         },
@@ -969,10 +1187,30 @@ export function parseCli(argv: string[]): ParsedCli {
         errors,
       };
     }
+    case "security": {
+      const subcommand = rest[0] as SecuritySubcommand | undefined;
+      if (!subcommand || !SECURITY_SUBCOMMANDS.includes(subcommand)) {
+        errors.push("forge security requires subcommand: prove");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "security",
+          subcommand,
+          db: parseAdapterKind(parseOptionValue(argv, "--db")),
+          databaseUrl: parseOptionValue(argv, "--database-url"),
+          json: parseFlag(argv, "--json"),
+          runTests: parseFlag(argv, "--full") || parseFlag(argv, "--run-tests"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
     case "auth": {
       const subcommand = rest[0] as AuthSubcommand | undefined;
       if (!subcommand || !AUTH_SUBCOMMANDS.includes(subcommand)) {
-        errors.push("forge auth requires subcommand: check, config, decode, test-token, or jwks");
+        errors.push("forge auth requires subcommand: check, config, decode, test-token, jwks, or prove");
         return { command: null, workspaceRoot, errors };
       }
       return {
@@ -990,7 +1228,7 @@ export function parseCli(argv: string[]): ParsedCli {
     case "rls": {
       const subcommand = rest[0] as RlsSubcommand | undefined;
       if (!subcommand || !RLS_SUBCOMMANDS.includes(subcommand)) {
-        errors.push("forge rls requires subcommand: generate, check, apply, or test");
+        errors.push("forge rls requires subcommand: generate, check, apply, test, or mutate-test");
         return { command: null, workspaceRoot, errors };
       }
       return {
@@ -1063,6 +1301,7 @@ export function parseCli(argv: string[]): ParsedCli {
           json: parseFlag(argv, "--json"),
           allowDirty: parseFlag(argv, "--allow-dirty"),
           allowPublicSourcemaps: parseFlag(argv, "--allow-public-sourcemaps"),
+          allowMissingLocalRelease: parseFlag(argv, "--allow-missing-local-release"),
           workspaceRoot,
         },
         workspaceRoot,
@@ -1082,6 +1321,8 @@ export function parseCli(argv: string[]): ParsedCli {
             ? undefined
             : primitive === "ui"
               ? rest[1] ?? "ui"
+              : primitive === "ai-chat"
+                ? rest[1] ?? "support"
               : rest[1];
       const explainPrimitive =
         primitive === "explain" ? (rest[1] as MakePrimitive | undefined) : undefined;
@@ -1092,7 +1333,7 @@ export function parseCli(argv: string[]): ParsedCli {
         errors.push("forge make explain requires a known primitive");
       }
       if (
-        !["list", "explain", "ui"].includes(primitive) &&
+        !["list", "explain", "ui", "ai-chat"].includes(primitive) &&
         !name
       ) {
         errors.push(`forge make ${primitive} requires a name or plan id`);
@@ -1132,7 +1373,7 @@ export function parseCli(argv: string[]): ParsedCli {
             event: parseOptionValue(argv, "--event"),
             trigger: parseOptionValue(argv, "--trigger"),
             component: parseOptionValue(argv, "--component"),
-            framework: parseOptionValue(argv, "--framework") as "vite" | "next" | undefined,
+            framework: parseOptionValue(argv, "--framework") as "vite" | "next" | "nuxt" | undefined,
             withAi: parseFlag(argv, "--with-ai"),
             withCrud: parseFlag(argv, "--with-crud"),
             withLiveQuery: parseFlag(argv, "--with-livequery"),
@@ -1411,6 +1652,215 @@ export function parseCli(argv: string[]): ParsedCli {
         errors,
       };
     }
+    case "bench": {
+      const subcommand = rest[0] as BenchSubcommand | undefined;
+      if (!subcommand || !BENCH_SUBCOMMANDS.includes(subcommand)) {
+        errors.push("forge bench requires subcommand: compiler");
+        return { command: null, workspaceRoot, errors };
+      }
+      const iterationsRaw = parseOptionValue(argv, "--iterations");
+      const warmupsRaw = parseOptionValue(argv, "--warmups");
+      const concurrencyRaw = parseOptionValue(argv, "--concurrency");
+      const iterations = iterationsRaw !== undefined ? Number(iterationsRaw) : 5;
+      const warmups = warmupsRaw !== undefined ? Number(warmupsRaw) : 1;
+      const concurrency = concurrencyRaw !== undefined ? Number(concurrencyRaw) : 4;
+      if (!Number.isFinite(iterations) || iterations < 1) {
+        errors.push("--iterations must be a number >= 1");
+      }
+      if (!Number.isFinite(warmups) || warmups < 0) {
+        errors.push("--warmups must be a number >= 0");
+      }
+      if (!Number.isFinite(concurrency) || concurrency < 1) {
+        errors.push("--concurrency must be a number >= 1");
+      }
+      return {
+        command: {
+          kind: "bench",
+          options: {
+            subcommand,
+            workspaceRoot,
+            json: parseFlag(argv, "--json"),
+            iterations: Math.floor(iterations),
+            warmups: Math.floor(warmups),
+            concurrency: Math.floor(concurrency),
+          },
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "cair": {
+      const subcommand = rest[0] as CairSubcommand | undefined;
+      if (!subcommand || !CAIR_SUBCOMMANDS.includes(subcommand)) {
+        errors.push("forge cair requires subcommand: snapshot, query, or action");
+        return { command: null, workspaceRoot, errors };
+      }
+      const formatRaw = parseOptionValue(argv, "--format");
+      if (formatRaw !== undefined && formatRaw !== "text" && formatRaw !== "json") {
+        errors.push("--format must be text or json");
+      }
+      const query = subcommand === "query" ? rest.slice(1).join(" ").trim() : undefined;
+      if (subcommand === "query" && !query) {
+        errors.push("forge cair query requires a CAIR query, for example: forge cair query \"Q STATUS\"");
+      }
+      const inputPath = parseOptionValue(argv, "--input");
+      const action = subcommand === "action"
+        ? rest.slice(1).filter((part, index, parts) => {
+          const previous = parts[index - 1];
+          if (part === "--dry-run" || part === "--plan" || part === "--json" || part === "--include-generated") {
+            return false;
+          }
+          if (part === "--format" || part === "--input") {
+            return false;
+          }
+          if (previous === "--format" || previous === "--input") {
+            return false;
+          }
+          return true;
+        }).join(" ").trim()
+        : undefined;
+      if (subcommand === "action" && !action && !inputPath) {
+        errors.push("forge cair action requires a CAIR action, for example: forge cair action \"A CREATE.FILE path=src/example.ts\"");
+      }
+      return {
+        command: {
+          kind: "cair",
+          options: {
+            subcommand,
+            workspaceRoot,
+            json: parseFlag(argv, "--json"),
+            format: formatRaw === "json" ? "json" : "text",
+            ...(query ? { query } : {}),
+            ...(action ? { action } : {}),
+            ...(inputPath ? { inputPath } : {}),
+            dryRun: parseFlag(argv, "--dry-run"),
+            plan: parseFlag(argv, "--plan"),
+            allowGenerated: parseFlag(argv, "--include-generated"),
+          },
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "status":
+      return {
+        command: {
+          kind: "status",
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    case "changed":
+      return {
+        command: {
+          kind: "changed",
+          json: parseFlag(argv, "--json"),
+          authoredOnly: parseFlag(argv, "--authored"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    case "diff": {
+      const target = (rest[0] ?? "authored") as "authored" | "generated" | "full";
+      if (!["authored", "generated", "full"].includes(target)) {
+        errors.push("forge diff requires target: authored, generated, or full");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "diff",
+          target,
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "handoff":
+      return {
+        command: {
+          kind: "handoff",
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    case "studio": {
+      const subcommand = rest[0];
+      if (
+        subcommand !== "attach" &&
+        subcommand !== "snapshot" &&
+        subcommand !== "watch" &&
+        subcommand !== "open" &&
+        subcommand !== "doctor" &&
+        subcommand !== "bridge" &&
+        subcommand !== "codex-server"
+      ) {
+        errors.push("forge studio requires subcommand: attach, snapshot, watch, open, doctor, bridge, or codex-server");
+        return { command: null, workspaceRoot, errors };
+      }
+      const previewPortRaw = parseOptionValue(argv, "--preview-port");
+      const previewPort = previewPortRaw !== undefined ? Number(previewPortRaw) : undefined;
+      if (
+        previewPortRaw !== undefined &&
+        (!Number.isInteger(previewPort) || previewPort! < 1)
+      ) {
+        errors.push("--preview-port must be an integer >= 1");
+      }
+      const intervalRaw = parseOptionValue(argv, "--interval-ms");
+      const intervalMs = intervalRaw !== undefined ? Number(intervalRaw) : undefined;
+      if (intervalRaw !== undefined && (!Number.isFinite(intervalMs) || intervalMs! < 1000)) {
+        errors.push("--interval-ms must be a number >= 1000");
+      }
+      const targets = parseOptionValues(argv, "--target");
+      const ignoredOptionValues = new Set(
+        [
+          ...targets,
+          parseOptionValue(argv, "--preview-url"),
+          parseOptionValue(argv, "--studio-url"),
+          parseOptionValue(argv, "--workspace-id"),
+          parseOptionValue(argv, "--tenant-id"),
+          parseOptionValue(argv, "--user-id"),
+          parseOptionValue(argv, "--role"),
+          previewPortRaw,
+          intervalRaw,
+        ].filter((value): value is string => typeof value === "string"),
+      );
+      const studioPath = rest.slice(1).find((item) => !ignoredOptionValues.has(item));
+      return {
+        command: {
+          kind: "studio",
+          subcommand,
+          path: studioPath,
+          previewUrl: parseOptionValue(argv, "--preview-url"),
+          previewPort: previewPort ? Math.floor(previewPort) : undefined,
+          studioUrl: parseOptionValue(argv, "--studio-url"),
+          intervalMs: intervalMs ? Math.floor(intervalMs) : undefined,
+          once: parseFlag(argv, "--once"),
+          workspaceId: parseOptionValue(argv, "--workspace-id"),
+          tenantId: parseOptionValue(argv, "--tenant-id"),
+          userId: parseOptionValue(argv, "--user-id"),
+          role: parseOptionValue(argv, "--role"),
+          targets: targets.length > 0 ? targets : ["codex"],
+          install: parseFlag(argv, "--install"),
+          start: !parseFlag(argv, "--no-start"),
+          bridge: !parseFlag(argv, "--no-bridge"),
+          writeSchemas: parseFlag(argv, "--write"),
+          probeAppServer: parseFlag(argv, "--probe") || parseFlag(argv, "--probe-codex-server"),
+          json: parseFlag(argv, "--json"),
+          dryRun: parseFlag(argv, "--dry-run"),
+          force: parseFlag(argv, "--force"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
     case "generate": {
       const concurrencyRaw = parseOptionValue(argv, "--concurrency");
       const concurrency = concurrencyRaw ? Number(concurrencyRaw) : 4;
@@ -1424,30 +1874,178 @@ export function parseCli(argv: string[]): ParsedCli {
           dryRun: parseFlag(argv, "--dry-run"),
           json: parseFlag(argv, "--json"),
           concurrency: Math.max(1, Math.floor(concurrency || 4)),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "delta": {
+      const subcommand = rest[0];
+      if (subcommand !== "status" && subcommand !== "repair") {
+        errors.push("forge delta requires subcommand: status or repair");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "delta",
+          subcommand,
+          json: parseFlag(argv, "--json"),
+          dryRun: parseFlag(argv, "--dry-run"),
+          yes: parseFlag(argv, "--yes"),
+          verbose: parseFlag(argv, "--verbose"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "session": {
+      const subcommand = rest[0];
+      if (subcommand !== "list" && subcommand !== "show" && subcommand !== "rename" && subcommand !== "merge" && subcommand !== "split" && subcommand !== "detach") {
+        errors.push("forge session requires subcommand: list, show, rename, merge, split, or detach");
+        return { command: null, workspaceRoot, errors };
+      }
+      const limitRaw = parseOptionValue(argv, "--limit");
+      const limit = limitRaw ? Number(limitRaw) : undefined;
+      if (limitRaw !== undefined && (!Number.isFinite(limit) || limit! < 1)) {
+        errors.push("--limit must be a number >= 1");
+      }
+      const sessionId = rest[1];
+      return {
+        command: {
+          kind: "session",
+          subcommand,
+          sessionId: subcommand === "detach" ? undefined : sessionId,
+          sourceSessionId: subcommand === "merge" ? rest[2] : undefined,
+          operationId: subcommand === "split" ? rest[2] : subcommand === "detach" ? rest[1] : undefined,
+          title: subcommand === "rename" ? rest.slice(2).join(" ") : undefined,
+          limit: limit ? Math.floor(limit) : undefined,
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "timeline": {
+      const limitRaw = parseOptionValue(argv, "--limit");
+      const kindFilter = parseOptionValue(argv, "--kind");
+      const sessionId = parseOptionValue(argv, "--session");
+      const rebuild = rest[0] === "rebuild";
+      const target = rebuild ? undefined : rest.find((item) => item !== kindFilter && item !== limitRaw && item !== sessionId);
+      const limit = limitRaw ? Number(limitRaw) : undefined;
+      if (limitRaw !== undefined && (!Number.isFinite(limit) || limit! < 1)) {
+        errors.push("--limit must be a number >= 1");
+      }
+      return {
+        command: {
+          kind: "timeline",
+          target,
+            kindFilter,
+            sessionId,
+            limit: limit ? Math.floor(limit) : undefined,
+            json: parseFlag(argv, "--json"),
+            rebuild,
+            forAgent: parseFlag(argv, "--for-agent"),
+            workspaceRoot,
+          },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "explain": {
+      const thing = rest[0] === "session" ? `session:${rest[1] ?? "current"}` : rest[0];
+      if (!thing) {
+        errors.push("forge explain requires a target");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "explain",
+          thing,
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "manifest": {
+      const subcommand = rest[0];
+      const path = rest[1];
+      if (subcommand !== "validate" && subcommand !== "import") {
+        errors.push("forge manifest requires subcommand validate or import");
+        return { command: null, workspaceRoot, errors };
+      }
+      if (!path) {
+        errors.push(`forge manifest ${subcommand} requires a manifest file path`);
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "manifest",
+          subcommand,
+          path,
+          json: parseFlag(argv, "--json"),
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
+    case "import": {
+      const subcommand = rest[0];
+      if (subcommand !== "analyze" && subcommand !== "inspect") {
+        errors.push("forge import requires subcommand analyze or inspect");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "import",
+          options: {
+            subcommand,
+            json: parseFlag(argv, "--json"),
+            dryRun: parseFlag(argv, "--dry-run"),
+            workspaceRoot,
+            entry: parseOptionValue(argv, "--entry"),
+            target: parseOptionValue(argv, "--target"),
+          },
         },
         workspaceRoot,
         errors,
       };
     }
     case "add": {
-      const alias = rest[0];
+      const subcommand = rest[0];
+      const explicitMode =
+        subcommand === "package"
+          ? "package"
+          : subcommand === "integration"
+            ? "integration"
+            : "auto";
+      const alias = explicitMode === "auto" ? rest[0] : rest[1];
       if (!alias) {
-        errors.push("forge add requires an integration alias");
+        errors.push(
+          explicitMode === "auto"
+            ? "forge add requires a package name or integration alias"
+            : `forge add ${subcommand} requires a target`,
+        );
         return { command: null, workspaceRoot, errors };
       }
       return {
         command: {
           kind: "add",
           alias,
-          options: parseAddOptions(argv, workspaceRoot),
+          options: parseAddOptions(argv, workspaceRoot, explicitMode),
         },
         workspaceRoot,
         errors,
       };
     }
     case "inspect": {
-      const target = rest[0] as InspectTarget | undefined;
-      if (!target || !INSPECT_TARGETS.includes(target)) {
+      const target = (rest[0] as InspectTarget | undefined) ?? "summary";
+      if (!INSPECT_TARGETS.includes(target)) {
         errors.push(
           `unsupported inspect target; supported: ${INSPECT_TARGETS.join(", ")}`,
         );
@@ -1459,6 +2057,8 @@ export function parseCli(argv: string[]): ParsedCli {
           target,
           json: parseFlag(argv, "--json"),
           dryRun: parseFlag(argv, "--dry-run"),
+          full: parseFlag(argv, "--full"),
+          brief: parseFlag(argv, "--brief"),
         },
         workspaceRoot,
         errors,
@@ -1479,12 +2079,58 @@ export function parseCli(argv: string[]): ParsedCli {
       {
         const scriptTimeoutRaw = parseOptionValue(argv, "--script-timeout-ms");
         const scriptTimeoutMs = scriptTimeoutRaw ? Number(scriptTimeoutRaw) : undefined;
+        const testJobsRaw = parseOptionValue(argv, "--test-jobs");
+        const testJobs = testJobsRaw ? Number(testJobsRaw) : undefined;
+        const typechecker = parseOptionValue(argv, "--typechecker");
+        const verifyOptionValues = new Set(
+          [scriptTimeoutRaw, testJobsRaw, typechecker]
+            .filter((value): value is string => typeof value === "string"),
+        );
+        const profileAlias = rest.find((item) => !verifyOptionValues.has(item));
+        const verifyProfiles = new Set([
+          "quick",
+          "smoke",
+          "agent",
+          "standard",
+          "release",
+          "strict",
+          "changed",
+          "framework",
+          "internal",
+          "maintainer",
+        ]);
+        if (profileAlias && !verifyProfiles.has(profileAlias)) {
+          errors.push(
+            `unknown forge verify profile '${profileAlias}'; expected quick, smoke, agent, standard, release, strict, changed, framework, internal, or maintainer`,
+          );
+        }
+        const internal =
+          parseFlag(argv, "--internal") ||
+          profileAlias === "framework" ||
+          profileAlias === "internal" ||
+          profileAlias === "maintainer";
         if (
           scriptTimeoutRaw !== undefined &&
           (!Number.isFinite(scriptTimeoutMs) || scriptTimeoutMs! < 1)
         ) {
           errors.push("--script-timeout-ms must be a number >= 1");
         }
+        if (
+          testJobsRaw !== undefined &&
+          (!Number.isInteger(testJobs) || testJobs! < 1)
+        ) {
+          errors.push("--test-jobs must be an integer >= 1");
+        }
+        if (
+          typechecker !== undefined &&
+          typechecker !== "tsc" &&
+          typechecker !== "native" &&
+          typechecker !== "ts7" &&
+          typechecker !== "tsgo" &&
+          typechecker !== "auto"
+        ) {
+          errors.push("--typechecker must be one of: tsc, native, ts7, tsgo, auto");
+        }
       return {
         command: {
           kind: "verify",
@@ -1494,12 +2140,17 @@ export function parseCli(argv: string[]): ParsedCli {
             skipTests: parseFlag(argv, "--skip-tests"),
             skipTypecheck: parseFlag(argv, "--skip-typecheck"),
             skipEslint: parseFlag(argv, "--skip-eslint"),
-            strict: parseFlag(argv, "--strict"),
-            changed: parseFlag(argv, "--changed"),
-            fast: parseFlag(argv, "--fast"),
-            smoke: parseFlag(argv, "--smoke"),
-            standard: parseFlag(argv, "--standard"),
+            strict: internal || parseFlag(argv, "--strict") || profileAlias === "release" || profileAlias === "strict",
+            changed: parseFlag(argv, "--changed") || profileAlias === "changed",
+            fast: parseFlag(argv, "--fast") || profileAlias === "quick",
+            smoke: parseFlag(argv, "--smoke") || profileAlias === "smoke",
+            standard: parseFlag(argv, "--standard") || profileAlias === "agent" || profileAlias === "standard",
             scriptTimeoutMs: scriptTimeoutMs ? Math.floor(scriptTimeoutMs) : undefined,
+            testJobs: testJobs ? Math.floor(testJobs) : undefined,
+            typechecker: typechecker as "tsc" | "native" | "ts7" | "tsgo" | "auto" | undefined,
+            fullTests: parseFlag(argv, "--full"),
+            testPlan: parseFlag(argv, "--test-plan"),
+            internal,
           },
         },
         workspaceRoot,
@@ -1543,6 +2194,15 @@ export function parseCli(argv: string[]): ParsedCli {
 
       const name = rest[0];
       const list = parseFlag(argv, "--list") || !name;
+      const argsRaw = parseOptionValue(argv, "--args");
+      let args: unknown = {};
+      if (argsRaw !== undefined) {
+        try {
+          args = JSON.parse(argsRaw);
+        } catch {
+          errors.push("--args must be valid JSON");
+        }
+      }
       return {
         command: {
           kind: "run",
@@ -1555,19 +2215,30 @@ export function parseCli(argv: string[]): ParsedCli {
           role: parseOptionValue(argv, "--role"),
           envFile: parseOptionValue(argv, "--env-file"),
           workspaceRoot,
+          args,
         },
         workspaceRoot,
         errors,
       };
     }
     case "query": {
-      const subcommand = (rest[0] ?? "list") as QuerySubcommand;
+      const requested = rest[0] as QuerySubcommand | undefined;
+      const subcommand =
+        !requested
+          ? "list"
+          : ["list", "run"].includes(requested)
+            ? requested
+            : "run";
       if (!["list", "run"].includes(subcommand)) {
         errors.push("forge query requires subcommand: list or run");
         return { command: null, workspaceRoot, errors };
       }
 
-      const queryName = subcommand === "run" ? rest[1] : undefined;
+      const queryName = subcommand === "run"
+        ? requested === "run"
+          ? rest[1]
+          : rest[0]
+        : undefined;
       if (subcommand === "run" && !queryName) {
         errors.push("forge query run requires a query name");
       }
@@ -1676,6 +2347,7 @@ export function parseCli(argv: string[]): ParsedCli {
             .map((value) => value.trim())
             .filter(Boolean),
           envFile: parseOptionValue(argv, "--env-file"),
+          skipStartupConsole: parseFlag(argv, "--skip-startup-console"),
           workspaceRoot,
         },
         workspaceRoot,
@@ -1684,8 +2356,8 @@ export function parseCli(argv: string[]): ParsedCli {
     }
     case "db": {
       const subcommand = rest[0] as DbSubcommand | undefined;
-      if (!subcommand || !["diff", "migrate", "reset", "status", "rls-check"].includes(subcommand)) {
-        errors.push("forge db requires subcommand: diff, migrate, reset, status, or rls-check");
+      if (!subcommand || !["diff", "migrate", "reset", "status", "doctor", "rls-check"].includes(subcommand)) {
+        errors.push("forge db requires subcommand: diff, migrate, reset, status, doctor, or rls-check");
         return { command: null, workspaceRoot, errors };
       }
       return {
@@ -1882,10 +2554,10 @@ export function parseCli(argv: string[]): ParsedCli {
       const subcommand = rest[0] as SecretsSubcommand | undefined;
       if (
         !subcommand ||
-        !["list", "check", "print", "set", "unset"].includes(subcommand)
+        !["list", "check", "print", "set", "unset", "prove"].includes(subcommand)
       ) {
         errors.push(
-          "forge secrets requires subcommand: list, check, print, set, or unset",
+          "forge secrets requires subcommand: list, check, print, set, unset, or prove",
         );
         return { command: null, workspaceRoot, errors };
       }
@@ -1925,13 +2597,17 @@ export function parseCli(argv: string[]): ParsedCli {
     }
     case "ai": {
       const subcommand = rest[0] as AiSubcommand | undefined;
-      if (!subcommand || !["providers", "check", "test", "models"].includes(subcommand)) {
-        errors.push("forge ai requires subcommand: providers, check, test, or models");
+      if (!subcommand || !AI_SUBCOMMANDS.includes(subcommand)) {
+        errors.push("forge ai requires subcommand: providers, check, test, models, tools, agents, redteam, or trace");
         return { command: null, workspaceRoot, errors };
       }
 
       const providerRaw = parseOptionValue(argv, "--provider");
       const provider = providerRaw as ForgeAiProvider | undefined;
+      const traceId = subcommand === "trace" ? rest[1] ?? parseOptionValue(argv, "--trace") : undefined;
+      if (subcommand === "trace" && !traceId) {
+        errors.push("forge ai trace requires a trace id");
+      }
 
       return {
         command: {
@@ -1942,6 +2618,11 @@ export function parseCli(argv: string[]): ParsedCli {
           model: parseOptionValue(argv, "--model"),
           prompt: parseOptionValue(argv, "--prompt"),
           mock: parseFlag(argv, "--mock"),
+          modelLevel: parseFlag(argv, "--model-level"),
+          live: parseFlag(argv, "--live"),
+          traceId,
+          db: parsePersistentDbKind(parseOptionValue(argv, "--db")),
+          databaseUrl: parseOptionValue(argv, "--database-url"),
           workspaceRoot,
         },
         workspaceRoot,
@@ -1956,8 +2637,11 @@ export function parseCli(argv: string[]): ParsedCli {
 
 export function hasUnknownOption(argv: string[]): string | null {
   const known = new Set([
+    "--version",
     "--check",
     "--json",
+    "--human",
+    "--for-agent",
     "--dry-run",
     "--plan",
     "--staged",
@@ -1988,10 +2672,14 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--smoke",
     "--standard",
     "--script-timeout-ms",
+    "--test-plan",
+    "--typechecker",
     "--timeout-ms",
     "--apply",
     "--runtime-inspect",
     "--allow-scripts",
+    "--frontend",
+    "--backend",
     "--yes",
     "--force",
     "--no-generate",
@@ -2009,6 +2697,8 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--policy",
     "--emit",
     "--event",
+    "--entry",
+    "--current",
     "--trigger",
     "--component",
     "--framework",
@@ -2036,6 +2726,7 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--video",
     "--base-url",
     "--runtime-url",
+    "--workspace",
     "--reuse-servers",
     "--start-servers",
     "--scenario",
@@ -2048,6 +2739,7 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--allow-high-risk",
     "--to",
     "--changed",
+    "--authored",
     "--env",
     "--input",
     "--provider",
@@ -2055,10 +2747,17 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--release",
     "--allow-dirty",
     "--allow-public-sourcemaps",
+    "--allow-missing-local-release",
+    "--prepared-only",
+    "--build",
+    "--install-venv",
     "--with-release",
     "--concurrency",
+    "--iterations",
+    "--warmups",
     "--sandbox-backend",
     "--skip-tests",
+    "--test-jobs",
     "--skip-typecheck",
     "--skip-eslint",
     "--mock",
@@ -2071,8 +2770,14 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--database-url",
     "--worker",
     "--no-worker",
+    "--no-start",
+    "--no-bridge",
+    "--probe",
+    "--probe-codex-server",
     "--once",
     "--limit",
+    "--kind",
+    "--session",
     "--input",
     "--args",
     "--step",
@@ -2085,7 +2790,9 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--strict-policies",
     "--strict",
     "--strict-secrets",
+    "--internal",
     "--env-file",
+    "--skip-startup-console",
     "--redacted",
     "--mock-ai",
     "--ai",
@@ -2108,12 +2815,25 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--postgres-version",
     "--runtime-port",
     "--web-port",
+    "--preview-port",
+    "--preview-url",
+    "--studio-url",
+    "--interval-ms",
+    "--workspace-id",
     "--poll-interval",
     "--allow-dev-auth",
     "--token",
     "--no-preserve-user-sections",
     "--no-skills",
     "--no-rules",
+    "--full",
+    "--brief",
+    "--verbose",
+    "--run-tests",
+    "--model-level",
+    "--live",
+    "--no-delta",
+    "--format",
   ]);
 
   for (let index = 0; index < argv.length; index++) {
@@ -2124,6 +2844,8 @@ export function hasUnknownOption(argv: string[]): string | null {
     if (known.has(arg)) {
       if (
         arg === "--concurrency" ||
+        arg === "--iterations" ||
+        arg === "--warmups" ||
         arg === "--field" ||
         arg === "--fields" ||
         arg === "--type" ||
@@ -2134,6 +2856,7 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--policy" ||
         arg === "--emit" ||
         arg === "--event" ||
+        arg === "--entry" ||
         arg === "--trigger" ||
         arg === "--component" ||
         arg === "--package" ||
@@ -2164,9 +2887,12 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--video" ||
         arg === "--base-url" ||
         arg === "--runtime-url" ||
+        arg === "--workspace" ||
         arg === "--scenario" ||
         arg === "--timeout" ||
         arg === "--timeout-ms" ||
+        arg === "--test-jobs" ||
+        arg === "--typechecker" ||
         arg === "--name" ||
         arg === "--auth-token" ||
         arg === "--sandbox-backend" ||
@@ -2175,6 +2901,8 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--db" ||
         arg === "--database-url" ||
         arg === "--limit" ||
+        arg === "--kind" ||
+        arg === "--session" ||
         arg === "--input" ||
         arg === "--args" ||
         arg === "--step" ||
@@ -2190,6 +2918,7 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--provider" ||
         arg === "--model" ||
         arg === "--prompt" ||
+        arg === "--format" ||
         arg === "--url" ||
         arg === "--template" ||
         arg === "--package-manager" ||
@@ -2197,6 +2926,11 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--postgres-version" ||
         arg === "--runtime-port" ||
         arg === "--web-port" ||
+        arg === "--preview-port" ||
+        arg === "--preview-url" ||
+        arg === "--studio-url" ||
+        arg === "--interval-ms" ||
+        arg === "--workspace-id" ||
         arg === "--poll-interval" ||
         arg === "--token"
         || arg === "--to" ||