@siteoshq/cli 1.13.0 → 2.0.0

package/dist/cli.js

@@ -17,7 +17,7 @@ __export(cookie_verification_exports, {
   verificationTarget: () => verificationTarget,
   verifyCookieWebsite: () => verifyCookieWebsite
 });
-import { z as z15 } from "zod";
+import { z as z12 } from "zod";
 function verificationTarget(websiteUrl, candidate) {
   const website = new URL(websiteUrl);
   const target = new URL(candidate ?? websiteUrl, website);
@@ -362,80 +362,80 @@ var Names, Service, Envelope, State, VerificationInstallation;
 var init_cookie_verification = __esm({
   "src/services/cookie-verification.ts"() {
     "use strict";
-    Names = z15.object({
-      exact: z15.array(z15.string()),
-      prefixes: z15.array(z15.string())
-    });
-    Service = z15.object({
-      key: z15.string(),
-      purposeKey: z15.string(),
-      lifecycle: z15.object({
-        scriptOrigins: z15.array(z15.string()),
-        iframeOrigins: z15.array(z15.string()),
-        pixelOrigins: z15.array(z15.string()),
+    Names = z12.object({
+      exact: z12.array(z12.string()),
+      prefixes: z12.array(z12.string())
+    });
+    Service = z12.object({
+      key: z12.string(),
+      purposeKey: z12.string(),
+      lifecycle: z12.object({
+        scriptOrigins: z12.array(z12.string()),
+        iframeOrigins: z12.array(z12.string()),
+        pixelOrigins: z12.array(z12.string()),
         firstPartyCookies: Names,
         localStorage: Names
       }).optional()
     });
-    Envelope = z15.object({
-      publicKey: z15.string(),
-      revision: z15.number(),
-      ruleKey: z15.string(),
-      profileKey: z15.string(),
-      trustedSignals: z15.object({
-        region: z15.object({
-          countryCode: z15.string().nullable(),
-          subdivisionCode: z15.string().nullable()
+    Envelope = z12.object({
+      publicKey: z12.string(),
+      revision: z12.number(),
+      ruleKey: z12.string(),
+      profileKey: z12.string(),
+      trustedSignals: z12.object({
+        region: z12.object({
+          countryCode: z12.string().nullable(),
+          subdivisionCode: z12.string().nullable()
         }).optional()
       }).optional(),
-      config: z15.object({
-        services: z15.array(Service),
-        categories: z15.array(z15.object({ key: z15.string(), required: z15.boolean() })),
-        integrations: z15.object({ googleConsentMode: z15.string() })
+      config: z12.object({
+        services: z12.array(Service),
+        categories: z12.array(z12.object({ key: z12.string(), required: z12.boolean() })),
+        integrations: z12.object({ googleConsentMode: z12.string() })
       })
     });
-    State = z15.object({
-      runtimeVersion: z15.string(),
-      preview: z15.boolean(),
-      resolved: z15.object({
-        publicKey: z15.string(),
-        revision: z15.number(),
-        ruleKey: z15.string(),
-        profileKey: z15.string()
+    State = z12.object({
+      runtimeVersion: z12.string(),
+      preview: z12.boolean(),
+      resolved: z12.object({
+        publicKey: z12.string(),
+        revision: z12.number(),
+        ruleKey: z12.string(),
+        profileKey: z12.string()
       }).nullable(),
-      consent: z15.object({
-        categories: z15.array(z15.string()),
-        decision: z15.string(),
-        globalPrivacyControl: z15.boolean(),
-        privacyChoices: z15.object({
-          saleOrShareOptOut: z15.boolean(),
-          targetedAdvertisingOptOut: z15.boolean()
+      consent: z12.object({
+        categories: z12.array(z12.string()),
+        decision: z12.string(),
+        globalPrivacyControl: z12.boolean(),
+        privacyChoices: z12.object({
+          saleOrShareOptOut: z12.boolean(),
+          targetedAdvertisingOptOut: z12.boolean()
         })
       }),
-      services: z15.array(
-        z15.object({
-          key: z15.string(),
-          allowed: z15.boolean(),
-          footprintPresent: z15.boolean()
+      services: z12.array(
+        z12.object({
+          key: z12.string(),
+          allowed: z12.boolean(),
+          footprintPresent: z12.boolean()
         })
       )
     });
-    VerificationInstallation = z15.object({
-      publicKey: z15.string(),
-      currentPublishedRevision: z15.number().int().positive(),
-      delivery: z15.object({
-        runtimeUrl: z15.string().url(),
-        configUrl: z15.string().url(),
-        analyticsUrl: z15.string().url().nullable(),
-        receiptsUrl: z15.string().url(),
-        handshakeUrl: z15.string().url()
+    VerificationInstallation = z12.object({
+      publicKey: z12.string(),
+      currentPublishedRevision: z12.number().int().positive(),
+      delivery: z12.object({
+        runtimeUrl: z12.string().url(),
+        configUrl: z12.string().url(),
+        analyticsUrl: z12.string().url().nullable(),
+        receiptsUrl: z12.string().url(),
+        handshakeUrl: z12.string().url()
       })
     });
   }
 });
 
 // src/health-check.ts
-import path10 from "path";
+import path8 from "path";
 
 // src/projects/project-context.ts
 import path6 from "path";
@@ -1033,13 +1033,6 @@ import { realpath } from "fs/promises";
 import path4 from "path";
 import { z as z3 } from "zod";
 
-// src/core/ports/project-binding-store.ts
-var PRODUCT_SERVICES = ["pulse", "forms", "search"];
-var PROJECT_BINDING_SERVICES = [
-  "project",
-  ...PRODUCT_SERVICES
-];
-
 // src/core/adapters/node-json-document-store.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 import {
@@ -1206,7 +1199,7 @@ function isNodeErrorCode2(error, code) {
 
 // src/core/adapters/node-project-binding-store.ts
 var projectBindingSchema = z3.object({
-  service: z3.enum(PROJECT_BINDING_SERVICES),
+  service: z3.literal("project"),
   apiOrigin: z3.string().url().refine((value) => new URL(value).origin === value),
   repositoryRoot: z3.string().refine(path4.isAbsolute),
   organizationId: z3.string().trim().min(1).max(255),
@@ -1331,13 +1324,13 @@ function normalizeApiOrigin(value) {
   } catch {
     throw new ProjectBindingStoreError(
       "PROJECT_BINDINGS_INVALID",
-      "The product Project binding is invalid."
+      "The Project binding is invalid."
     );
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") {
     throw new ProjectBindingStoreError(
       "PROJECT_BINDINGS_INVALID",
-      "The product Project binding is invalid."
+      "The Project binding is invalid."
     );
   }
   return url.origin;
@@ -1350,26 +1343,26 @@ function mapStoreError(error) {
   if (error instanceof z3.ZodError) {
     return new ProjectBindingStoreError(
       "PROJECT_BINDINGS_INVALID",
-      "Product Project bindings are invalid."
+      "Project bindings are invalid."
     );
   }
   if (error instanceof JsonDocumentStoreError) {
     if (error.code === "JSON_DOCUMENT_CONFLICT") {
       return new ProjectBindingStoreError(
         "PROJECT_BINDINGS_CONFLICT",
-        "Product Project bindings changed before they could be saved."
+        "Project bindings changed before they could be saved."
       );
     }
     if (error.code === "JSON_DOCUMENT_INVALID" || error.code === "JSON_DOCUMENT_UNSAFE") {
       return new ProjectBindingStoreError(
         "PROJECT_BINDINGS_INVALID",
-        "Product Project bindings are invalid."
+        "Project bindings are invalid."
       );
     }
   }
   return new ProjectBindingStoreError(
     "PROJECT_BINDINGS_UNAVAILABLE",
-    "Product Project bindings could not be accessed."
+    "Project bindings could not be accessed."
   );
 }
 
@@ -1439,6 +1432,12 @@ function isNodeErrorCode3(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
+// src/environment-slug.ts
+var environmentSlugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isValidEnvironmentSlug(value) {
+  return value.length >= 2 && value.length <= 30 && environmentSlugPattern.test(value);
+}
+
 // src/projects/project-api.ts
 import { z as z4 } from "zod";
 var PROJECT_SERVICES = [
@@ -1502,7 +1501,7 @@ var OverviewSchema = z4.object({
 });
 function createProjectApi(input) {
   const origin = resolveSiteOSAuthBaseUrl(input.env);
-  async function request(path33, schema, body, method) {
+  async function request(path29, schema, body, method) {
     const scope = body === void 0 ? "projects:workspace:read" : "projects:workspace:write";
     const grant = await input.grants.acquire({
       audience: "siteos-projects",
@@ -1516,7 +1515,7 @@ function createProjectApi(input) {
         message: "SiteOS API access is unavailable."
       });
     const response = await input.fetchImpl(
-      `${origin}/api/projects/v1/projects${path33}`,
+      `${origin}/api/projects/v1/projects${path29}`,
       {
         method: method ?? (body === void 0 ? "GET" : "POST"),
         headers: {
@@ -1660,7 +1659,7 @@ function invalidResponse() {
 // src/projects/project-context.ts
 function commonProjectRuntime(options) {
   const store = options.projectBindingStore ?? new NodeProjectBindingStore(
-    path6.join(resolveSiteOSConfigHome(options), "project-bindings.json")
+    path6.join(resolveSiteOSConfigHome(options), "projects.json")
   );
   const grants = options.serviceGrantProvider ?? createSiteOSServiceGrantProvider(options);
   return { store, grants, api: createProjectApi({ ...options, grants }) };
@@ -1681,7 +1680,12 @@ async function readCommonProject(options, environmentSlug) {
   const local = await readLocalCommonProject(options);
   if (!local) return null;
   const { api, binding } = local;
-  const selectedSlug = environmentSlug ?? binding.environmentSlug ?? "production";
+  const selectedSlug = environmentSlug ?? binding.environmentSlug;
+  if (!selectedSlug)
+    throw new SiteOSAuthApiError({
+      code: "PROJECT_ENVIRONMENT_REQUIRED",
+      message: "Select an environment with `siteos project environment use <slug>`."
+    });
   const overview = await api.get(binding.project.id, selectedSlug);
   if (overview.project.organizationId !== binding.organizationId)
     throw new SiteOSAuthApiError({
@@ -1732,11 +1736,6 @@ async function commonEnvironmentArguments(options, service, args2) {
     throw cause;
   });
   if (!local) return args2;
-  if (args2[0] === "environment" && args2[1] !== "list")
-    throw new Error(
-      "Manage shared environments with `siteos project environment` or Project settings."
-    );
-  if (["project", "environment", "submit"].includes(args2[0] ?? "")) return args2;
   const normalized = args2.flatMap(
     (arg) => arg.startsWith("--environment=") ? ["--environment", arg.slice("--environment=".length)] : [arg]
   );
@@ -1745,6 +1744,8 @@ async function commonEnvironmentArguments(options, service, args2) {
   const index = normalized.indexOf("--environment");
   const slug2 = index >= 0 ? normalized[index + 1] : void 0;
   if (index >= 0 && (!slug2 || slug2.startsWith("--"))) return args2;
+  if (slug2 && !isValidEnvironmentSlug(slug2))
+    throw new Error("--environment must be a valid environment slug.");
   const context = await commonServiceContext(options, service, slug2);
   const binding = context?.environmentBinding;
   if (!context || !binding?.slug)
@@ -1757,113 +1758,11 @@ async function commonEnvironmentArguments(options, service, args2) {
   return result;
 }
 
-// src/forms/project-reference.ts
-import path7 from "path";
-import { z as z5 } from "zod";
-var FORMS_PROJECT_REFERENCE_RELATIVE_PATH = path7.join(
-  ".siteos",
-  "forms",
-  "project.json"
-);
-var formsProjectReferenceSchema = z5.object({
-  version: z5.literal(1),
-  service: z5.literal("forms"),
-  project: z5.object({
-    name: z5.string().trim().min(1).max(255),
-    slug: z5.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
-  }).strict()
-}).strict();
-var codec = {
-  decode(input) {
-    return { migrated: false, value: formsProjectReferenceSchema.parse(input) };
-  },
-  encode(value) {
-    return formsProjectReferenceSchema.parse(value);
-  }
-};
-var FormsProjectReferenceError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "FormsProjectReferenceError";
-    this.code = code;
-  }
-};
-async function inspectFormsProjectReference(startDir, documents = new NodeJsonDocumentStore()) {
-  try {
-    const rootDir = await findRepositoryRoot(startDir);
-    const snapshot = await documents.read({
-      codec,
-      filePath: path7.join(rootDir, FORMS_PROJECT_REFERENCE_RELATIVE_PATH),
-      security: "tracked"
-    });
-    if (snapshot.status === "missing") return { rootDir, status: "missing" };
-    return {
-      checksum: snapshot.checksum,
-      reference: snapshot.value,
-      rootDir,
-      status: "loaded"
-    };
-  } catch (error) {
-    throw mapReferenceError(error);
-  }
-}
-async function writeFormsProjectReference(options) {
-  const reference = formsProjectReferenceSchema.parse({
-    version: 1,
-    service: "forms",
-    project: options.project
-  });
-  try {
-    await (options.documents ?? new NodeJsonDocumentStore()).write({
-      codec,
-      expectedChecksum: options.expectedChecksum,
-      filePath: path7.join(
-        await findRepositoryRoot(options.rootDir),
-        FORMS_PROJECT_REFERENCE_RELATIVE_PATH
-      ),
-      security: "tracked",
-      value: reference
-    });
-    return reference;
-  } catch (error) {
-    throw mapReferenceError(error);
-  }
-}
-function mapReferenceError(error) {
-  if (error instanceof FormsProjectReferenceError) return error;
-  if (error instanceof RepositoryRootError) throw error;
-  if (error instanceof JsonDocumentStoreError) {
-    if (error.code === "JSON_DOCUMENT_CONFLICT") {
-      return new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_CONFLICT",
-        "The Forms Project reference changed before it could be saved."
-      );
-    }
-    if (error.code === "JSON_DOCUMENT_INVALID" || error.code === "JSON_DOCUMENT_UNSAFE") {
-      return new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_INVALID",
-        "The Forms Project reference is invalid."
-      );
-    }
-  }
-  if (error instanceof z5.ZodError) {
-    return new FormsProjectReferenceError(
-      "FORMS_PROJECT_REFERENCE_INVALID",
-      "The Forms Project reference is invalid."
-    );
-  }
-  return new FormsProjectReferenceError(
-    "FORMS_PROJECT_REFERENCE_UNAVAILABLE",
-    "The Forms Project reference could not be accessed."
-  );
-}
-
 // src/pulse/config.ts
 import { createHash as createHash3, randomBytes } from "crypto";
 import { readFile as readFile3, rename as rename3, unlink, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
-import { z as z6 } from "zod";
+import path7 from "path";
+import { z as z5 } from "zod";
 
 // src/pulse/errors.ts
 var CliError = class extends Error {
@@ -1882,44 +1781,43 @@ var CliError = class extends Error {
 // src/pulse/config.ts
 var CONFIG_FILE = "siteos.config.json";
 function isSafeRelativePath(value) {
-  if (!value || path8.isAbsolute(value) || value.startsWith("!")) return false;
+  if (!value || path7.isAbsolute(value) || value.startsWith("!")) return false;
   return !value.split(/[\\/]/).includes("..");
 }
-var safeRelativePath = z6.string().trim().min(1).refine(
+var safeRelativePath = z5.string().trim().min(1).refine(
   isSafeRelativePath,
   "Use a relative path without '..' or negated glob patterns."
 );
-var slug = z6.string().trim().min(1).max(80).regex(
+var slug = z5.string().trim().min(1).max(80).regex(
   /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
   "Use lowercase letters, numbers, and hyphens."
 );
-var displayName = z6.string().trim().min(1).max(120);
-var httpUrl = z6.string().url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol), {
+var displayName = z5.string().trim().min(1).max(120);
+var httpUrl = z5.string().url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol), {
   message: "Use an HTTP or HTTPS URL."
 });
-var legacySchedule = z6.object({
-  enabled: z6.boolean().default(true),
-  cadenceSeconds: z6.number().int().min(60).max(2592e3).default(300)
+var legacySchedule = z5.object({
+  enabled: z5.boolean().default(true),
+  cadenceSeconds: z5.number().int().min(60).max(2592e3).default(300)
 }).default({ enabled: true, cadenceSeconds: 300 });
-var ChecksConfigV1Schema = z6.object({
-  version: z6.literal(1),
+var ChecksConfigV1Schema = z5.object({
+  version: z5.literal(1),
   project: slug,
   suite: slug.default("smoke"),
   testsDir: safeRelativePath.default("tests/checks"),
   playwrightConfig: safeRelativePath.optional(),
-  include: z6.array(safeRelativePath).min(1).max(100),
+  include: z5.array(safeRelativePath).min(1).max(100),
   baseUrl: httpUrl.optional(),
-  schedule: legacySchedule,
-  apiUrl: httpUrl.optional()
+  schedule: legacySchedule
 });
-var ScheduledConfigSchema = z6.object({
-  mode: z6.literal("scheduled"),
-  cadenceSeconds: z6.number().int().min(60).max(2592e3).default(300)
+var ScheduledConfigSchema = z5.object({
+  mode: z5.literal("scheduled"),
+  cadenceSeconds: z5.number().int().min(60).max(2592e3).default(300)
 });
-var ManualConfigSchema = z6.object({ mode: z6.literal("manual") });
-var CheckConfigSchema = z6.object({
-  environmentVariables: z6.array(
-    z6.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).refine(
+var ManualConfigSchema = z5.object({ mode: z5.literal("manual") });
+var CheckConfigSchema = z5.object({
+  environmentVariables: z5.array(
+    z5.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).refine(
       (name) => !/^(?:SITEOS_|PLAYWRIGHT_|DOCKER_|NODE_|NPM_|PNPM_|LD_|DYLD_)/.test(
         name
       ) && ![
@@ -1940,29 +1838,28 @@ var CheckConfigSchema = z6.object({
   ).optional(),
   slug,
   name: displayName,
-  include: z6.array(safeRelativePath).min(1).max(100),
-  active: z6.boolean().default(true),
-  schedule: z6.discriminatedUnion("mode", [ScheduledConfigSchema, ManualConfigSchema]).default({ mode: "scheduled", cadenceSeconds: 300 })
+  include: z5.array(safeRelativePath).min(1).max(100),
+  active: z5.boolean().default(true),
+  schedule: z5.discriminatedUnion("mode", [ScheduledConfigSchema, ManualConfigSchema]).default({ mode: "scheduled", cadenceSeconds: 300 })
 });
-var ChecksConfigV2Schema = z6.object({
-  version: z6.literal(2),
-  project: z6.object({
+var ChecksConfigV2Schema = z5.object({
+  version: z5.literal(2),
+  project: z5.object({
     slug,
     name: displayName,
     baseUrl: httpUrl.optional(),
-    monitoringEnabled: z6.boolean().default(true)
+    monitoringEnabled: z5.boolean().default(true)
   }),
   testsDir: safeRelativePath.default("tests/siteos"),
   playwrightConfig: safeRelativePath.optional(),
-  bundle: z6.object({ include: z6.array(safeRelativePath).max(500).default([]) }).strict().optional(),
-  checks: z6.array(CheckConfigSchema).min(1).max(100),
-  apiUrl: httpUrl.optional()
+  bundle: z5.object({ include: z5.array(safeRelativePath).max(500).default([]) }).strict().optional(),
+  checks: z5.array(CheckConfigSchema).min(1).max(100)
 }).superRefine((config, context) => {
   const slugs = /* @__PURE__ */ new Set();
   for (const [index, check] of config.checks.entries()) {
     if (slugs.has(check.slug)) {
       context.addIssue({
-        code: z6.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         path: ["checks", index, "slug"],
         message: `Duplicate Check slug: ${check.slug}`
       });
@@ -1970,7 +1867,7 @@ var ChecksConfigV2Schema = z6.object({
     slugs.add(check.slug);
   }
 });
-var ChecksConfigSchema = z6.union([
+var ChecksConfigSchema = z5.union([
   ChecksConfigV1Schema,
   ChecksConfigV2Schema
 ]);
@@ -2003,8 +1900,7 @@ function normalizeChecksConfig(config) {
           cadenceSeconds: config.schedule.cadenceSeconds
         } : { mode: "manual" }
       }
-    ],
-    apiUrl: config.apiUrl
+    ]
   });
 }
 async function fileExists(filePath) {
@@ -2017,7 +1913,7 @@ async function fileExists(filePath) {
   }
 }
 async function findChecksConfigFile(projectRoot) {
-  return await fileExists(path8.join(projectRoot, CONFIG_FILE)) ? CONFIG_FILE : null;
+  return await fileExists(path7.join(projectRoot, CONFIG_FILE)) ? CONFIG_FILE : null;
 }
 async function loadChecksConfigFile(projectRoot) {
   return (await loadChecksConfigSnapshot(projectRoot)).fileConfig;
@@ -2033,7 +1929,7 @@ async function loadChecksConfigSnapshot(projectRoot) {
       }
     );
   }
-  const configPath = path8.join(projectRoot, configFile);
+  const configPath = path7.join(projectRoot, configFile);
   let source;
   try {
     source = await readFile3(configPath, "utf8");
@@ -2081,8 +1977,8 @@ async function loadChecksConfig(projectRoot) {
 }
 async function saveChecksConfig(projectRoot, config, options = {}) {
   const configFile = await findChecksConfigFile(projectRoot) ?? CONFIG_FILE;
-  const configPath = path8.join(projectRoot, configFile);
-  const temporaryPath = path8.join(
+  const configPath = path7.join(projectRoot, configFile);
+  const temporaryPath = path7.join(
     projectRoot,
     `.${configFile}.${process.pid}.${randomBytes(6).toString("hex")}`
   );
@@ -2119,19 +2015,6 @@ async function saveChecksConfig(projectRoot, config, options = {}) {
     throw error;
   }
 }
-async function reconcileProjectSlug(projectRoot, projectSlug2, options = {}) {
-  const snapshot = await loadChecksConfigSnapshot(projectRoot);
-  const config = ChecksConfigV2Schema.parse({
-    ...snapshot.config,
-    project: { ...snapshot.config.project, slug: projectSlug2 }
-  });
-  if (config.project.slug !== snapshot.config.project.slug || snapshot.migrationRequired) {
-    await saveChecksConfig(projectRoot, config, {
-      expectedChecksum: options.expectedChecksum ?? snapshot.checksum
-    });
-  }
-  return loadChecksConfigSnapshot(projectRoot);
-}
 function projectSlug(value) {
   const normalized = value.trim().toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 80);
   return normalized || "siteos-pulse-project";
@@ -2143,111 +2026,6 @@ function projectDisplayName(value) {
   return name.slice(0, 120) || "SiteOS Pulse Project";
 }
 
-// src/search/project-reference.ts
-import path9 from "path";
-import { z as z7 } from "zod";
-var SEARCH_PROJECT_REFERENCE_RELATIVE_PATH = path9.join(
-  ".siteos",
-  "search",
-  "project.json"
-);
-var searchProjectReferenceSchema = z7.object({
-  version: z7.literal(1),
-  service: z7.literal("search"),
-  project: z7.object({
-    name: z7.string().trim().min(1).max(255),
-    slug: z7.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
-  }).strict()
-}).strict();
-var codec2 = {
-  decode(input) {
-    return {
-      migrated: false,
-      value: searchProjectReferenceSchema.parse(input)
-    };
-  },
-  encode(value) {
-    return searchProjectReferenceSchema.parse(value);
-  }
-};
-var SearchProjectReferenceError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "SearchProjectReferenceError";
-    this.code = code;
-  }
-};
-async function inspectSearchProjectReference(startDir, documents = new NodeJsonDocumentStore()) {
-  try {
-    const rootDir = await findRepositoryRoot(startDir);
-    const snapshot = await documents.read({
-      codec: codec2,
-      filePath: path9.join(rootDir, SEARCH_PROJECT_REFERENCE_RELATIVE_PATH),
-      security: "tracked"
-    });
-    if (snapshot.status === "missing") return { rootDir, status: "missing" };
-    return {
-      checksum: snapshot.checksum,
-      reference: snapshot.value,
-      rootDir,
-      status: "loaded"
-    };
-  } catch (error) {
-    throw mapReferenceError2(error);
-  }
-}
-async function writeSearchProjectReference(options) {
-  const reference = searchProjectReferenceSchema.parse({
-    version: 1,
-    service: "search",
-    project: options.project
-  });
-  try {
-    await (options.documents ?? new NodeJsonDocumentStore()).write({
-      codec: codec2,
-      expectedChecksum: options.expectedChecksum,
-      filePath: path9.join(
-        await findRepositoryRoot(options.rootDir),
-        SEARCH_PROJECT_REFERENCE_RELATIVE_PATH
-      ),
-      security: "tracked",
-      value: reference
-    });
-    return reference;
-  } catch (error) {
-    throw mapReferenceError2(error);
-  }
-}
-function mapReferenceError2(error) {
-  if (error instanceof SearchProjectReferenceError) return error;
-  if (error instanceof RepositoryRootError) throw error;
-  if (error instanceof JsonDocumentStoreError) {
-    if (error.code === "JSON_DOCUMENT_CONFLICT") {
-      return new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_CONFLICT",
-        "The Search Project reference changed before it could be saved."
-      );
-    }
-    if (error.code === "JSON_DOCUMENT_INVALID" || error.code === "JSON_DOCUMENT_UNSAFE") {
-      return new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_INVALID",
-        "The Search Project reference is invalid."
-      );
-    }
-  }
-  if (error instanceof z7.ZodError) {
-    return new SearchProjectReferenceError(
-      "SEARCH_PROJECT_REFERENCE_INVALID",
-      "The Search Project reference is invalid."
-    );
-  }
-  return new SearchProjectReferenceError(
-    "SEARCH_PROJECT_REFERENCE_UNAVAILABLE",
-    "The Search Project reference could not be accessed."
-  );
-}
-
 // src/health-check.ts
 async function createHealthCheckResult(options = {}) {
   const packageMetadata = options.packageMetadata ?? {
@@ -2260,7 +2038,7 @@ async function createHealthCheckResult(options = {}) {
     homeDir: options.homeDir
   });
   const repositoryRoot = await optionalRepositoryRoot(cwd);
-  const productProjects = repositoryRoot ? await inspectProductProjects(repositoryRoot) : missingProductProjects(cwd);
+  const pulse = repositoryRoot ? await inspectPulse(repositoryRoot) : { path: path8.join(cwd, CONFIG_FILE), status: "missing" };
   let project = { status: "missing" };
   if (repositoryRoot) {
     try {
@@ -2278,13 +2056,11 @@ async function createHealthCheckResult(options = {}) {
       project = { status: "invalid" };
     }
   }
-  const configured = project.status === "selected" || Object.values(productProjects).some(
-    (project2) => project2.status === "configured"
-  );
+  const configured = project.status === "selected";
   return {
     checks: {
       configHome: { path: configHome, status: "ok" },
-      productProjects,
+      pulse,
       project,
       repository: repositoryRoot ? { rootDir: repositoryRoot, status: "ok" } : { status: "missing" }
     },
@@ -2307,41 +2083,8 @@ async function optionalRepositoryRoot(cwd) {
     throw error;
   }
 }
-async function inspectProductProjects(repositoryRoot) {
-  const [forms, pulse, search] = await Promise.all([
-    inspectReference(
-      "forms",
-      path10.join(repositoryRoot, FORMS_PROJECT_REFERENCE_RELATIVE_PATH),
-      () => inspectFormsProjectReference(repositoryRoot)
-    ),
-    inspectPulse(repositoryRoot),
-    inspectReference(
-      "search",
-      path10.join(repositoryRoot, SEARCH_PROJECT_REFERENCE_RELATIVE_PATH),
-      () => inspectSearchProjectReference(repositoryRoot)
-    )
-  ]);
-  return { forms, pulse, search };
-}
-async function inspectReference(service, referencePath, inspect) {
-  try {
-    const state = await inspect();
-    return state.status === "loaded" ? {
-      path: referencePath,
-      slug: state.reference.project.slug,
-      status: "configured",
-      version: state.reference.version
-    } : { path: referencePath, status: "missing" };
-  } catch (error) {
-    return {
-      error: error instanceof Error && "code" in error ? String(error.code) : `${service.toUpperCase()}_PROJECT_REFERENCE_INVALID`,
-      path: referencePath,
-      status: "invalid"
-    };
-  }
-}
 async function inspectPulse(repositoryRoot) {
-  const configPath = path10.join(repositoryRoot, CONFIG_FILE);
+  const configPath = path8.join(repositoryRoot, CONFIG_FILE);
   try {
     const snapshot = await loadChecksConfigSnapshot(repositoryRoot);
     return {
@@ -2361,27 +2104,13 @@ async function inspectPulse(repositoryRoot) {
     };
   }
 }
-function missingProductProjects(cwd) {
-  const root = path10.resolve(cwd);
-  return {
-    forms: {
-      path: path10.join(root, FORMS_PROJECT_REFERENCE_RELATIVE_PATH),
-      status: "missing"
-    },
-    pulse: { path: path10.join(root, CONFIG_FILE), status: "missing" },
-    search: {
-      path: path10.join(root, SEARCH_PROJECT_REFERENCE_RELATIVE_PATH),
-      status: "missing"
-    }
-  };
-}
 
 // src/auth-command.ts
 import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import os3 from "os";
-import { z as z8 } from "zod";
+import { z as z6 } from "zod";
 var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-var organizationDisplayNameSchema = z8.string().transform((value) => value.trim()).refine((value) => {
+var organizationDisplayNameSchema = z6.string().transform((value) => value.trim()).refine((value) => {
   const visibleLength = Array.from(value).length;
   return visibleLength >= 2 && visibleLength <= 80;
 });
@@ -2412,7 +2141,7 @@ async function runAuthCommand(options) {
   if (subcommand === "start") {
     const parsed = parseValueCommand(args2, "--email");
     if (!parsed.ok) return usageError(parsed.error, parsed.json);
-    const email = z8.string().trim().email().safeParse(parsed.value);
+    const email = z6.string().trim().email().safeParse(parsed.value);
     if (!email.success) return usageError("--email is invalid.", parsed.json);
     return runStart({
       ...options,
@@ -2425,7 +2154,7 @@ async function runAuthCommand(options) {
   if (subcommand === "complete") {
     const parsed = parseValueCommand(args2, "--token");
     if (!parsed.ok) return usageError(parsed.error, parsed.json);
-    const token = z8.string().trim().regex(/^[A-Za-z0-9_-]{16}$/).safeParse(parsed.value);
+    const token = z6.string().trim().regex(/^[A-Za-z0-9_-]{16}$/).safeParse(parsed.value);
     if (!token.success) return usageError("--token is invalid.", parsed.json);
     return runComplete({
       ...options,
@@ -2960,137 +2689,124 @@ function isCliExitCode(value) {
 
 // src/forms-command.ts
 import { readFile as readFile5 } from "fs/promises";
-import path12 from "path";
-import { z as z10 } from "zod";
+import path10 from "path";
 import { Ajv } from "ajv";
 import addFormats from "ajv-formats";
+import { z as z8 } from "zod";
 
 // src/siteos-forms-api.ts
-import { z as z9 } from "zod";
-var DEFAULT_SITEOS_FORMS_BASE_URL = "https://app.siteos.sh";
-var SITEOS_FORMS_BASE_URL_ENV = "SITEOS_FORMS_PUBLIC_URL";
-var opaqueIdentifierSchema = z9.string().trim().min(1).max(255);
-var formsProjectSchema = z9.object({
-  createdAt: z9.string().datetime({ offset: true }),
-  id: opaqueIdentifierSchema,
-  name: z9.string().trim().min(1).max(255),
-  organizationId: opaqueIdentifierSchema,
-  slug: z9.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  updatedAt: z9.string().datetime({ offset: true })
-}).strict();
-var formsProjectListSchema = z9.object({ projects: z9.array(formsProjectSchema) }).strict();
-var formsProjectResponseSchema = z9.object({ project: formsProjectSchema }).strict();
-var formsEnvironmentSchema = z9.object({
-  createdAt: z9.string().datetime({ offset: true }),
+import { z as z7 } from "zod";
+var opaqueIdentifierSchema = z7.string().trim().min(1).max(255);
+var formsEnvironmentSchema = z7.object({
+  createdAt: z7.string().datetime({ offset: true }),
   id: opaqueIdentifierSchema,
-  name: z9.string().trim().min(1).max(255),
+  name: z7.string().trim().min(1).max(255),
   projectId: opaqueIdentifierSchema,
-  slug: z9.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  updatedAt: z9.string().datetime({ offset: true })
+  slug: z7.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  updatedAt: z7.string().datetime({ offset: true })
 }).strict();
-var formsEnvironmentListSchema = z9.object({ environments: z9.array(formsEnvironmentSchema) }).strict();
-var formsEnvironmentResponseSchema = z9.object({ environment: formsEnvironmentSchema }).strict();
-var formDefinitionSyncResponseSchema = z9.object({
+var formsEnvironmentListSchema = z7.object({ environments: z7.array(formsEnvironmentSchema) }).strict();
+var formDefinitionSyncResponseSchema = z7.object({
   activeVersionId: opaqueIdentifierSchema,
-  createdForm: z9.boolean(),
-  createdVersion: z9.boolean(),
+  createdForm: z7.boolean(),
+  createdVersion: z7.boolean(),
   formId: opaqueIdentifierSchema,
   formKey: opaqueIdentifierSchema,
-  success: z9.literal(true),
-  version: z9.number().int().positive()
+  success: z7.literal(true),
+  version: z7.number().int().positive()
 }).strict();
-var definitionSchema = z9.object({
+var definitionSchema = z7.object({
   id: opaqueIdentifierSchema,
   environmentId: opaqueIdentifierSchema,
   formKey: opaqueIdentifierSchema,
-  name: z9.string(),
-  sourcePagePath: z9.string().nullable(),
-  activeVersion: z9.number().int().positive(),
+  name: z7.string(),
+  sourcePagePath: z7.string().nullable(),
+  activeVersion: z7.number().int().positive(),
   activeVersionId: opaqueIdentifierSchema,
-  status: z9.enum(["active", "inactive"]),
-  submissionCount: z9.number().int().nonnegative(),
-  lastSubmittedAt: z9.string().datetime({ offset: true }).nullable(),
-  createdAt: z9.string().datetime({ offset: true }),
-  updatedAt: z9.string().datetime({ offset: true })
+  status: z7.enum(["active", "inactive"]),
+  submissionCount: z7.number().int().nonnegative(),
+  lastSubmittedAt: z7.string().datetime({ offset: true }).nullable(),
+  createdAt: z7.string().datetime({ offset: true }),
+  updatedAt: z7.string().datetime({ offset: true })
 });
-var definitionListSchema = z9.object({
-  definitions: z9.array(definitionSchema)
+var definitionListSchema = z7.object({
+  definitions: z7.array(definitionSchema)
 });
-var definitionContextSchema = z9.object({
+var definitionContextSchema = z7.object({
   definition: definitionSchema,
-  revision: z9.number().int().positive(),
-  canManage: z9.boolean(),
-  project: z9.object({ id: opaqueIdentifierSchema, name: z9.string() }),
-  environment: z9.object({
+  revision: z7.number().int().positive(),
+  canManage: z7.boolean(),
+  project: z7.object({ id: opaqueIdentifierSchema, name: z7.string() }),
+  environment: z7.object({
     id: opaqueIdentifierSchema,
-    name: z9.string(),
-    slug: z9.string()
+    name: z7.string(),
+    slug: z7.string()
   })
 });
-var definitionChangeResponseSchema = z9.object({
-  deleted: z9.boolean(),
+var definitionChangeResponseSchema = z7.object({
+  deleted: z7.boolean(),
   formId: opaqueIdentifierSchema
 });
-var formSubmissionResponseSchema = z9.object({
+var formSubmissionResponseSchema = z7.object({
   formId: opaqueIdentifierSchema,
-  receivedAt: z9.string().datetime({ offset: true }),
+  receivedAt: z7.string().datetime({ offset: true }),
   submissionId: opaqueIdentifierSchema,
-  success: z9.literal(true)
+  success: z7.literal(true)
 }).strict();
-var formsSubmissionStatusSchema = z9.enum([
+var formsSubmissionStatusSchema = z7.enum([
   "new",
   "read",
   "archived",
   "spam"
 ]);
-var submissionSummarySchema = z9.object({
+var submissionSummarySchema = z7.object({
   id: opaqueIdentifierSchema,
   formId: opaqueIdentifierSchema,
-  normalized: z9.record(
-    z9.union([z9.string(), z9.number(), z9.boolean(), z9.null()])
+  normalized: z7.record(
+    z7.union([z7.string(), z7.number(), z7.boolean(), z7.null()])
   ),
   status: formsSubmissionStatusSchema,
-  submittedAt: z9.string().datetime({ offset: true })
+  submittedAt: z7.string().datetime({ offset: true })
 });
 var submissionDetailSchema = submissionSummarySchema.extend({
-  payload: z9.record(z9.unknown()),
-  fields: z9.array(
-    z9.object({
-      key: z9.string(),
-      label: z9.string().optional(),
-      kind: z9.string().optional(),
-      displayRole: z9.enum(["primary", "secondary"]).optional(),
-      multiple: z9.boolean().optional(),
-      options: z9.array(z9.object({ value: z9.string(), label: z9.string() })).optional()
+  payload: z7.record(z7.unknown()),
+  fields: z7.array(
+    z7.object({
+      key: z7.string(),
+      label: z7.string().optional(),
+      kind: z7.string().optional(),
+      displayRole: z7.enum(["primary", "secondary"]).optional(),
+      multiple: z7.boolean().optional(),
+      options: z7.array(z7.object({ value: z7.string(), label: z7.string() })).optional()
     })
   ),
-  version: z9.number().int().positive(),
+  version: z7.number().int().positive(),
   versionId: opaqueIdentifierSchema
 });
-var submissionPageSchema = z9.object({
-  submissions: z9.array(submissionSummarySchema),
-  total: z9.number().int().nonnegative(),
-  nextCursor: z9.string().nullable()
+var submissionPageSchema = z7.object({
+  submissions: z7.array(submissionSummarySchema),
+  total: z7.number().int().nonnegative(),
+  nextCursor: z7.string().nullable()
 });
-var submissionDetailResponseSchema = z9.object({
+var submissionDetailResponseSchema = z7.object({
   submission: submissionDetailSchema
 });
-var formsCredentialMetadataSchema = z9.object({
-  createdAt: z9.string().datetime({ offset: true }),
-  id: z9.string().trim().min(1).max(255),
-  lastUsedAt: z9.string().datetime({ offset: true }).nullable(),
-  name: z9.string().trim().min(1).max(255),
-  projectEnvironmentId: z9.string().trim().min(1).max(255),
-  revokedAt: z9.string().datetime({ offset: true }).nullable(),
-  status: z9.enum(["active", "revoked"])
+var formsCredentialMetadataSchema = z7.object({
+  createdAt: z7.string().datetime({ offset: true }),
+  id: z7.string().trim().min(1).max(255),
+  lastUsedAt: z7.string().datetime({ offset: true }).nullable(),
+  name: z7.string().trim().min(1).max(255),
+  projectEnvironmentId: z7.string().trim().min(1).max(255),
+  revokedAt: z7.string().datetime({ offset: true }).nullable(),
+  status: z7.enum(["active", "revoked"])
 }).strict();
-var formsCredentialListSchema = z9.object({
-  tokens: z9.array(formsCredentialMetadataSchema)
+var formsCredentialListSchema = z7.object({
+  tokens: z7.array(formsCredentialMetadataSchema)
 }).strict();
 var formsCredentialExchangeSchema = formsCredentialMetadataSchema.extend({
-  token: z9.string().regex(/^pfs_[A-Za-z0-9_-]{22}$/)
+  token: z7.string().regex(/^pfs_[A-Za-z0-9_-]{22}$/)
 });
-var formsErrorCodeSchema = z9.enum([
+var formsErrorCodeSchema = z7.enum([
   "AUTHENTICATION_REQUIRED",
   "FORBIDDEN",
   "CONFLICT",
@@ -3138,10 +2854,10 @@ var safeFormsErrorMessages = {
   SERVICE_UNAVAILABLE: "The Forms service is unavailable.",
   INTERNAL_ERROR: "The Forms request could not be completed."
 };
-var apiErrorResponseSchema = z9.object({
-  error: z9.object({
+var apiErrorResponseSchema = z7.object({
+  error: z7.object({
     code: formsErrorCodeSchema,
-    message: z9.string().trim().min(1).max(240)
+    message: z7.string().trim().min(1).max(240)
   }).strict()
 }).strict();
 var SiteOSFormsApiError = class extends Error {
@@ -3154,20 +2870,15 @@ var SiteOSFormsApiError = class extends Error {
     this.status = options.status;
   }
 };
-function resolveSiteOSFormsBaseUrl(env = process.env) {
-  return normalizeFormsOrigin(
-    env[SITEOS_FORMS_BASE_URL_ENV]?.trim() || DEFAULT_SITEOS_FORMS_BASE_URL
-  );
-}
-var deploymentResponseSchema = z9.object({
+var deploymentResponseSchema = z7.object({
   environmentId: opaqueIdentifierSchema,
-  forms: z9.array(
-    z9.object({
+  forms: z7.array(
+    z7.object({
       formKey: opaqueIdentifierSchema,
       formId: opaqueIdentifierSchema,
-      contractVersion: z9.string().regex(/^sha256:[a-f0-9]{64}$/),
+      contractVersion: z7.string().regex(/^sha256:[a-f0-9]{64}$/),
       versionId: opaqueIdentifierSchema,
-      version: z9.number().int().positive()
+      version: z7.number().int().positive()
     })
   )
 });
@@ -3236,24 +2947,6 @@ function createSiteOSFormsApiClient(options) {
       body: { status: input.status, expectedStatus: input.expectedStatus },
       responseSchema: submissionDetailResponseSchema
     }),
-    createProject: (input) => requestJson2({
-      apiBaseUrl,
-      body: { name: input.name, slug: input.slug },
-      fetchImpl: options.fetchImpl,
-      headers: managementHeaders(input),
-      method: "POST",
-      path: "/api/v1/forms/projects",
-      responseSchema: formsProjectResponseSchema
-    }),
-    createEnvironment: (input) => requestJson2({
-      apiBaseUrl,
-      body: { name: input.name, slug: input.slug },
-      fetchImpl: options.fetchImpl,
-      headers: managementHeaders(input),
-      method: "POST",
-      path: environmentCollectionPath(input),
-      responseSchema: formsEnvironmentResponseSchema
-    }),
     issueCredential: (input) => requestJson2({
       apiBaseUrl,
       body: input.name ? { name: input.name } : {},
@@ -3262,7 +2955,7 @@ function createSiteOSFormsApiClient(options) {
       method: "POST",
       path: keyCollection(input),
       responseSchema: options.deploymentKeys ? formsCredentialExchangeSchema.extend({
-        token: z9.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
+        token: z7.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
       }) : formsCredentialExchangeSchema
     }),
     listEnvironments: (input) => requestJson2({
@@ -3273,14 +2966,6 @@ function createSiteOSFormsApiClient(options) {
       path: environmentCollectionPath(input),
       responseSchema: formsEnvironmentListSchema
     }),
-    listProjects: (input) => requestJson2({
-      apiBaseUrl,
-      fetchImpl: options.fetchImpl,
-      headers: managementHeaders(input),
-      method: "GET",
-      path: "/api/v1/forms/projects",
-      responseSchema: formsProjectListSchema
-    }),
     listCredentials: (input) => requestJson2({
       apiBaseUrl,
       fetchImpl: options.fetchImpl,
@@ -3305,7 +2990,7 @@ function createSiteOSFormsApiClient(options) {
       method: "POST",
       path: credentialRotatePath(input),
       responseSchema: options.deploymentKeys ? formsCredentialExchangeSchema.extend({
-        token: z9.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
+        token: z7.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
       }) : formsCredentialExchangeSchema
     }),
     submitForm: (input) => requestJson2({
@@ -3433,7 +3118,7 @@ import {
   rm as rm3,
   writeFile as writeFile4
 } from "fs/promises";
-import path11 from "path";
+import path9 from "path";
 var SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV = "SITEOS_FORMS_SUBMISSION_CREDENTIAL";
 var SITEOS_FORMS_DEPLOYMENT_KEY_ENV = "SITEOS_FORMS_DEPLOYMENT_KEY";
 var SiteOSFormsCredentialStorageError = class extends Error {
@@ -3449,8 +3134,8 @@ var SiteOSFormsCredentialStorageError = class extends Error {
 async function prepareSiteOSFormsCredentialInstallation(options) {
   const variable = options.deployment ? SITEOS_FORMS_DEPLOYMENT_KEY_ENV : SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV;
   const credentialPattern = options.deployment ? /^pfd_[A-Za-z0-9_-]{43}$/ : /^pfs_[A-Za-z0-9_-]{22}$/;
-  const projectRoot = path11.resolve(options.projectRoot);
-  const dotenvPath = path11.join(projectRoot, ".env");
+  const projectRoot = path9.resolve(options.projectRoot);
+  const dotenvPath = path9.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot(projectRoot);
     if (!await isDotenvIgnored(projectRoot)) {
@@ -3524,7 +3209,7 @@ async function readSafeDotenv(dotenvPath) {
   return content;
 }
 async function writeCredentialAtomically(options) {
-  const temporaryPath = path11.join(
+  const temporaryPath = path9.join(
     options.projectRoot,
     `.siteos-forms-credential.${process.pid}.${randomUUID3()}.tmp`
   );
@@ -3577,12 +3262,6 @@ function isNodeErrorCode4(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
-// src/environment-slug.ts
-var environmentSlugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function isValidEnvironmentSlug(value) {
-  return value.length >= 2 && value.length <= 30 && environmentSlugPattern.test(value);
-}
-
 // src/forms-command.ts
 var HELP_FLAGS2 = /* @__PURE__ */ new Set(["--help", "-h"]);
 var JSON_FLAG = "--json";
@@ -3591,28 +3270,26 @@ var MANIFEST_FLAG = "--manifest";
 var ENVIRONMENT_FLAG = "--environment";
 var INSTALL_FLAG = "--install";
 var NAME_FLAG = "--name";
-var SLUG_FLAG = "--slug";
 var CREDENTIAL_FLAG = "--credential";
-var REPLACE_FLAG = "--replace";
-var normalizedFieldOptionSchema = z10.object({
-  label: z10.string().trim().min(1).max(255),
-  value: z10.string().trim().min(1).max(255)
+var normalizedFieldOptionSchema = z8.object({
+  label: z8.string().trim().min(1).max(255),
+  value: z8.string().trim().min(1).max(255)
 });
-var normalizedFieldSchema = z10.object({
-  key: z10.string().trim().min(1).max(255),
-  kind: z10.string().trim().min(1).max(64).optional(),
-  label: z10.string().trim().min(1).max(255).optional(),
-  displayRole: z10.enum(["primary", "secondary"]).optional(),
-  multiple: z10.boolean().optional(),
-  options: z10.array(normalizedFieldOptionSchema).max(500).optional()
+var normalizedFieldSchema = z8.object({
+  key: z8.string().trim().min(1).max(255),
+  kind: z8.string().trim().min(1).max(64).optional(),
+  label: z8.string().trim().min(1).max(255).optional(),
+  displayRole: z8.enum(["primary", "secondary"]).optional(),
+  multiple: z8.boolean().optional(),
+  options: z8.array(normalizedFieldOptionSchema).max(500).optional()
 }).strict();
-var definitionSyncInputSchema = z10.object({
-  formKey: z10.string().trim().min(1).max(255),
-  name: z10.string().trim().min(1).max(255),
-  normalizedFieldsJson: z10.array(normalizedFieldSchema).min(1).max(500),
-  schemaJson: z10.record(z10.unknown()),
-  sourceExportId: z10.string().trim().min(1).max(255).optional(),
-  sourcePagePath: z10.string().trim().min(1).max(2048).optional()
+var definitionSyncInputSchema = z8.object({
+  formKey: z8.string().trim().min(1).max(255),
+  name: z8.string().trim().min(1).max(255),
+  normalizedFieldsJson: z8.array(normalizedFieldSchema).min(1).max(500),
+  schemaJson: z8.record(z8.unknown()),
+  sourceExportId: z8.string().trim().min(1).max(255).optional(),
+  sourcePagePath: z8.string().trim().min(1).max(2048).optional()
 }).strict().superRefine((definition, context) => {
   const ajv = new Ajv({
     allErrors: true,
@@ -3624,7 +3301,7 @@ var definitionSyncInputSchema = z10.object({
     ajv.compile(definition.schemaJson);
   } catch {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "schemaJson must be an executable JSON Schema supported by SiteOS Forms.",
       path: ["schemaJson"]
     });
@@ -3633,7 +3310,7 @@ var definitionSyncInputSchema = z10.object({
   const duplicateKeys = fields.map((field) => field.key).filter((key, index, keys) => keys.indexOf(key) !== index);
   for (const key of new Set(duplicateKeys)) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `Field key "${key}" is registered more than once.`,
       path: ["normalizedFieldsJson"]
     });
@@ -3643,7 +3320,7 @@ var definitionSyncInputSchema = z10.object({
   );
   if (primaryFields.length !== 1) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "Exactly one managed field must use the primary display role.",
       path: ["normalizedFieldsJson"]
     });
@@ -3651,7 +3328,7 @@ var definitionSyncInputSchema = z10.object({
   const schemaProperties = definition.schemaJson.properties;
   if (!isRecord(schemaProperties)) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "schemaJson.properties must define the managed form fields.",
       path: ["schemaJson", "properties"]
     });
@@ -3661,7 +3338,7 @@ var definitionSyncInputSchema = z10.object({
   for (const key of Object.keys(schemaProperties)) {
     if (!metadataKeys.has(key)) {
       context.addIssue({
-        code: z10.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Schema field "${key}" is missing managed field metadata.`,
         path: ["normalizedFieldsJson"]
       });
@@ -3670,7 +3347,7 @@ var definitionSyncInputSchema = z10.object({
   for (const [index, field] of fields.entries()) {
     if (!Object.prototype.hasOwnProperty.call(schemaProperties, field.key)) {
       context.addIssue({
-        code: z10.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Managed field "${field.key}" is missing from schemaJson.properties.`,
         path: ["normalizedFieldsJson", index, "key"]
       });
@@ -3680,33 +3357,27 @@ var definitionSyncInputSchema = z10.object({
   const requiredFields = definition.schemaJson.required;
   if (primaryField && (!Array.isArray(requiredFields) || !requiredFields.includes(primaryField.key))) {
     context.addIssue({
-      code: z10.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `Primary display field "${primaryField.key}" must be required by schemaJson.`,
       path: ["schemaJson", "required"]
     });
   }
 });
-var definitionManifestSchema = z10.object({
-  version: z10.literal(1),
-  forms: z10.array(z10.string().trim().min(1)).min(1)
+var definitionManifestSchema = z8.object({
+  version: z8.literal(1),
+  forms: z8.array(z8.string().trim().min(1)).min(1)
 });
-var submitInputSchema = z10.object({
-  formKey: z10.string().trim().min(1),
-  idempotencyKey: z10.string().trim().min(1),
-  ipAddress: z10.string().trim().min(1).optional(),
-  payload: z10.record(z10.unknown()),
-  sourceUrl: z10.string().trim().min(1).optional(),
-  userAgent: z10.string().trim().min(1).optional()
+var submitInputSchema = z8.object({
+  formKey: z8.string().trim().min(1),
+  idempotencyKey: z8.string().trim().min(1),
+  ipAddress: z8.string().trim().min(1).optional(),
+  payload: z8.record(z8.unknown()),
+  sourceUrl: z8.string().trim().min(1).optional(),
+  userAgent: z8.string().trim().min(1).optional()
 }).passthrough();
-var environmentNameSchema = z10.string().transform((value) => value.trim()).refine((value) => value.length >= 1 && value.length <= 255);
-var projectSlugSchema = z10.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var environmentNameSchema = z8.string().transform((value) => value.trim()).refine((value) => value.length >= 1 && value.length <= 255);
+var projectSlugSchema = z8.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 var FORMS_HELP = `Usage:
-  siteos forms project list [--json]
-  siteos forms project create --slug <slug> --name <name> [--json]
-  siteos forms project use <slug> [--replace] [--json]
-  siteos forms project status [--json]
-  siteos forms environment list [--json]
-  siteos forms environment create --slug <slug> --name <name> [--json]
   siteos forms definition sync --environment <slug> --input <path> [--json]
   siteos forms definition sync --environment <slug> --manifest <path> [--json]
   siteos forms definition list --environment <slug> [--status <active|inactive|all>] [--json]
@@ -3720,7 +3391,6 @@ var FORMS_HELP = `Usage:
   siteos forms credential issue --environment <slug> --install [--name <name>] [--json]
   siteos forms credential rotate --environment <slug> --install [--name <name>] [--json]
   siteos forms credential revoke --environment <slug> --credential <credential-id> [--json]
-  siteos forms credentials issue --environment <slug> [--name <name>] [--json]
   siteos forms submissions list --environment <slug> --form <form-id> [--query <text>] [--status <status>] [--from <ISO>] [--to <ISO>] [--limit <1-100>] [--cursor <cursor>] [--json]
   siteos forms submissions read --environment <slug> --form <form-id> --submission <id> [--json]
   siteos forms submissions status --environment <slug> --form <form-id> --submission <id> --status <new|read|archived|spam> --expected-status <status> [--json]
@@ -3739,12 +3409,26 @@ async function runFormsCommand(options) {
       stdout: FORMS_HELP
     };
   }
+  const environmentFlags = args2.flatMap(
+    (arg) => arg.startsWith("--environment=") ? ["--environment", arg.slice(14)] : [arg]
+  );
+  const environmentIndex = environmentFlags.indexOf("--environment");
+  options = {
+    ...options,
+    selectedEnvironment: environmentIndex >= 0 ? environmentFlags[environmentIndex + 1] : void 0
+  };
+  if (["project", "environment"].includes(args2[0] ?? ""))
+    return usageError2(
+      "Use `siteos project` to manage Projects and environments."
+    );
   if (args2[0] === "deploy")
     return runDeployment({ ...options, args: args2.slice(1) });
-  if (args2[0] !== "submit" && args2[0] !== "project") {
+  if (args2[0] !== "submit") {
     try {
       args2 = await commonEnvironmentArguments(options, "forms", args2);
     } catch (error) {
+      if (error instanceof SiteOSAuthApiError)
+        return formatAuthError(error).error;
       return {
         exitCode: 1,
         stderr: error instanceof Error ? error.message : "Environment could not be selected."
@@ -3759,18 +3443,6 @@ async function runFormsCommand(options) {
       args: args2.slice(1)
     });
   }
-  if (args2[0] === "environment") {
-    return runEnvironmentCommand({
-      ...options,
-      args: args2.slice(1)
-    });
-  }
-  if (args2[0] === "project") {
-    return runProjectCommand({
-      ...options,
-      args: args2.slice(1)
-    });
-  }
   if (args2[0] === "submit") {
     return runSubmit({
       ...options,
@@ -3790,17 +3462,6 @@ async function runFormsCommand(options) {
       args: args2.slice(1)
     });
   }
-  if (args2[0] === "credentials" && args2[1] === "issue") {
-    const compatibilityArgs = args2.slice(2);
-    return runCredentialCommand({
-      ...options,
-      args: [
-        "issue",
-        ...compatibilityArgs,
-        ...compatibilityArgs.includes(INSTALL_FLAG) ? [] : [INSTALL_FLAG]
-      ]
-    });
-  }
   return usageError2("Unknown SiteOS forms command.");
 }
 async function runSubmissionsCommand(options) {
@@ -3850,7 +3511,7 @@ async function runSubmissionsCommand(options) {
   if ((value("query")?.length ?? 0) > 200 || (value("cursor")?.length ?? 0) > 2048)
     return usageError2("The query or cursor is too long.");
   for (const key of ["from", "to"])
-    if (value(key) && !z10.string().datetime({ offset: true }).safeParse(value(key)).success)
+    if (value(key) && !z8.string().datetime({ offset: true }).safeParse(value(key)).success)
       return usageError2(
         `--${key} must be an ISO timestamp including a timezone.`
       );
@@ -3872,7 +3533,7 @@ async function runSubmissionsCommand(options) {
     );
     if (!environment)
       return usageError2(
-        "The selected Forms Environment does not exist. Run forms environment list."
+        "The selected Forms Environment does not exist. Run siteos project environment list."
       );
     const input = {
       grant: context.grant,
@@ -3893,277 +3554,56 @@ async function runSubmissionsCommand(options) {
     return formatApiError(error);
   }
 }
-async function runProjectCommand(options) {
+async function runCredentialCommand(options) {
   const action = options.args[0];
-  if (!action || !["create", "list", "status", "use"].includes(action)) {
-    return usageError2("Unknown SiteOS forms project command.");
+  if (!action || !["issue", "list", "revoke", "rotate"].includes(action)) {
+    return usageError2("Unknown SiteOS forms credential command.");
   }
-  const parsed = parseProjectFlags(action, options.args.slice(1));
-  if (!parsed.ok) return parsed.error;
-  if (!options.fetchImpl) {
-    return formatApiError(
-      new SiteOSFormsApiError({
-        code: "FORMS_UNAVAILABLE",
-        message: "SiteOS Forms access is unavailable in this runtime."
-      })
+  if (options.deployment && action === "rotate")
+    return usageError2(
+      "Issue a new deployment key, update the release secret, then revoke the old key."
     );
-  }
+  const variable = options.deployment ? SITEOS_FORMS_DEPLOYMENT_KEY_ENV : SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV;
+  const parsed = parseCredentialFlags(action, options.args.slice(1));
+  if (!parsed.ok) return parsed.error;
+  const context = await loadCredentialManagementContext({
+    ...options,
+    install: parsed.install
+  });
+  if (!context.ok) return context.error;
   try {
-    const apiBaseUrl = resolveSiteOSFormsBaseUrl(options.env);
-    const grant = await serviceGrantProvider(options).acquire({
-      audience: "siteos-forms",
-      scopes: ["forms:workspace:write"]
-    });
-    requireGrant(grant, "forms:workspace:write");
-    const client = createSiteOSFormsApiClient({
-      apiBaseUrl,
-      fetchImpl: options.fetchImpl
-    });
     if (action === "list") {
-      const response = await client.listProjects({ grant: grant.accessToken });
-      requireProjectOrganization(response.projects, grant.grant.organizationId);
+      const response = await context.client.listCredentials({
+        environmentSlug: parsed.environmentSlug,
+        grant: context.grant,
+        projectId: context.project.id
+      });
+      const output2 = {
+        credentials: response.tokens,
+        environment: parsed.environmentSlug
+      };
       return {
         exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(response) : formatProjectListOutput(response.projects)
+        stdout: parsed.json ? stringifySafeJson(output2) : formatCredentialListOutput(output2)
       };
     }
-    if (action === "create") {
-      const response = await client.createProject({
-        grant: grant.accessToken,
-        name: parsed.name,
-        slug: parsed.slug
+    if (action === "revoke") {
+      const credential2 = await context.client.revokeCredential({
+        credentialId: parsed.credentialId,
+        environmentSlug: parsed.environmentSlug,
+        grant: context.grant,
+        projectId: context.project.id
       });
-      requireProjectOrganization(
-        [response.project],
-        grant.grant.organizationId
-      );
+      const output2 = {
+        credential: credential2,
+        environment: parsed.environmentSlug,
+        revoked: true
+      };
       return {
         exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(response) : [
-          "SiteOS Forms Project created.",
-          `Project: ${response.project.slug}`,
-          `Name: ${response.project.name}`,
-          "Run `siteos forms project use " + response.project.slug + "` to select it for this repository."
-        ].join("\n")
-      };
-    }
-    const reference = await inspectFormsProjectReference(
-      options.cwd ?? process.cwd()
-    );
-    const store = projectBindingStore(options);
-    const locator = {
-      apiOrigin: apiBaseUrl,
-      repositoryRoot: reference.rootDir,
-      service: "forms"
-    };
-    if (action === "use") {
-      const response = await client.listProjects({ grant: grant.accessToken });
-      requireProjectOrganization(response.projects, grant.grant.organizationId);
-      const matches = response.projects.filter(
-        (project3) => project3.slug === parsed.slug
-      );
-      if (matches.length !== 1) {
-        throw new SiteOSFormsApiError({
-          code: matches.length === 0 ? "PROJECT_NOT_FOUND" : "INVALID_RESPONSE",
-          message: matches.length === 0 ? "The Forms Project was not found." : "SiteOS Forms returned an invalid response.",
-          status: matches.length === 0 ? 404 : void 0
-        });
-      }
-      const project2 = matches[0];
-      if (reference.status === "loaded" && reference.reference.project.slug !== project2.slug && !parsed.replace) {
-        throw new FormsProjectReferenceError(
-          "FORMS_PROJECT_REFERENCE_CONFLICT",
-          "A different Forms Project is already selected. Use --replace to replace it."
-        );
-      }
-      const previousBinding = await store.read(locator);
-      await store.write({
-        ...locator,
-        organizationId: grant.grant.organizationId,
-        project: { id: project2.id, slug: project2.slug }
-      });
-      try {
-        await writeFormsProjectReference({
-          expectedChecksum: reference.status === "loaded" ? reference.checksum : null,
-          project: { name: project2.name, slug: project2.slug },
-          rootDir: reference.rootDir
-        });
-      } catch (error) {
-        if (previousBinding) await store.write(previousBinding);
-        else await store.remove(locator);
-        throw error;
-      }
-      const output2 = {
-        apiOrigin: apiBaseUrl,
-        organizationId: grant.grant.organizationId,
-        project: project2,
-        referencePath: path12.join(
-          reference.rootDir,
-          ".siteos",
-          "forms",
-          "project.json"
-        )
-      };
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(output2) : [
-          "SiteOS Forms Project selected.",
-          `Project: ${project2.slug}`,
-          `Reference: ${output2.referencePath}`
-        ].join("\n")
-      };
-    }
-    if (reference.status === "missing") {
-      throw new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_REQUIRED",
-        "Select a Forms Project for this repository first."
-      );
-    }
-    const binding = await store.read(locator);
-    if (!binding) {
-      throw new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_REQUIRED",
-        "Select a Forms Project for this repository first."
-      );
-    }
-    if (binding.organizationId !== grant.grant.organizationId || binding.project.slug !== reference.reference.project.slug) {
-      throw new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_INVALID",
-        "The Forms Project reference and private binding do not match."
-      );
-    }
-    const projects = await client.listProjects({ grant: grant.accessToken });
-    requireProjectOrganization(projects.projects, grant.grant.organizationId);
-    const project = projects.projects.find(
-      (candidate) => candidate.id === binding.project.id
-    );
-    if (!project || project.slug !== binding.project.slug) {
-      throw new SiteOSFormsApiError({
-        code: "PROJECT_NOT_FOUND",
-        message: "The Forms Project was not found.",
-        status: 404
-      });
-    }
-    const output = {
-      apiOrigin: apiBaseUrl,
-      connected: true,
-      organizationId: binding.organizationId,
-      project,
-      repositoryRoot: reference.rootDir
-    };
-    return {
-      exitCode: 0,
-      stdout: parsed.json ? stringifySafeJson(output) : [
-        "SiteOS Forms Project connection is valid.",
-        `Project: ${project.slug}`,
-        `Organization: ${binding.organizationId}`,
-        `API: ${apiBaseUrl}`
-      ].join("\n")
-    };
-  } catch (error) {
-    return formatProjectError(error);
-  }
-}
-async function runEnvironmentCommand(options) {
-  const action = options.args[0];
-  if (!action || !["create", "list"].includes(action)) {
-    return usageError2("Unknown SiteOS forms environment command.");
-  }
-  const parsed = parseEnvironmentFlags(action, options.args.slice(1));
-  if (!parsed.ok) return parsed.error;
-  const context = await loadFormsManagementContext(
-    options,
-    "forms:workspace:write"
-  );
-  if (!context.ok) return context.error;
-  try {
-    if (action === "list") {
-      const response2 = await context.client.listEnvironments({
-        grant: context.grant,
-        projectId: context.project.id
-      });
-      requireEnvironmentProjectConvergence(
-        response2.environments,
-        context.project.id
-      );
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(response2) : formatEnvironmentListOutput(response2.environments)
-      };
-    }
-    const response = await context.client.createEnvironment({
-      grant: context.grant,
-      name: parsed.name,
-      projectId: context.project.id,
-      slug: parsed.slug
-    });
-    requireEnvironmentProjectConvergence(
-      [response.environment],
-      context.project.id
-    );
-    return {
-      exitCode: 0,
-      stdout: parsed.json ? stringifySafeJson(response) : [
-        "SiteOS Forms Environment created.",
-        `Environment: ${response.environment.slug}`,
-        `Name: ${response.environment.name}`,
-        `Project: ${response.environment.projectId}`
-      ].join("\n")
-    };
-  } catch (error) {
-    return formatApiError(error);
-  }
-}
-async function runCredentialCommand(options) {
-  const action = options.args[0];
-  if (!action || !["issue", "list", "revoke", "rotate"].includes(action)) {
-    return usageError2("Unknown SiteOS forms credential command.");
-  }
-  if (options.deployment && action === "rotate")
-    return usageError2(
-      "Issue a new deployment key, update the release secret, then revoke the old key."
-    );
-  const variable = options.deployment ? SITEOS_FORMS_DEPLOYMENT_KEY_ENV : SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV;
-  const parsed = parseCredentialFlags(action, options.args.slice(1));
-  if (!parsed.ok) return parsed.error;
-  const context = await loadCredentialManagementContext({
-    ...options,
-    install: parsed.install
-  });
-  if (!context.ok) return context.error;
-  try {
-    if (action === "list") {
-      const response = await context.client.listCredentials({
-        environmentSlug: parsed.environmentSlug,
-        grant: context.grant,
-        projectId: context.project.id
-      });
-      const output2 = {
-        credentials: response.tokens,
-        environment: parsed.environmentSlug
-      };
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(output2) : formatCredentialListOutput(output2)
-      };
-    }
-    if (action === "revoke") {
-      const credential2 = await context.client.revokeCredential({
-        credentialId: parsed.credentialId,
-        environmentSlug: parsed.environmentSlug,
-        grant: context.grant,
-        projectId: context.project.id
-      });
-      const output2 = {
-        credential: credential2,
-        environment: parsed.environmentSlug,
-        revoked: true
-      };
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson(output2) : `SiteOS Forms credential revoked.
-Credential: ${credential2.id}
-Environment: ${parsed.environmentSlug}`
+        stdout: parsed.json ? stringifySafeJson(output2) : `SiteOS Forms credential revoked.
+Credential: ${credential2.id}
+Environment: ${parsed.environmentSlug}`
       };
     }
     const previousCredentials = action === "rotate" ? (await context.client.listCredentials({
@@ -4215,7 +3655,12 @@ Environment: ${parsed.environmentSlug}`
 async function loadCredentialManagementContext(options) {
   try {
     const local = await readLocalCommonProject(options);
-    const rootDir = local?.rootDir ?? (await requireFormsProjectReference(options.cwd ?? process.cwd())).rootDir;
+    if (!local)
+      throw new SiteOSAuthApiError({
+        code: "PROJECT_REQUIRED",
+        message: "Select a Project with `siteos project use <id-or-slug>`."
+      });
+    const rootDir = local.rootDir;
     const installation = options.install ? await (options.prepareCredentialInstallation ?? prepareSiteOSFormsCredentialInstallation)({
       projectRoot: rootDir,
       ...options.deployment ? { deployment: true } : {}
@@ -4242,31 +3687,41 @@ async function loadCredentialManagementContext(options) {
 }
 async function loadFormsManagementContext(options, scope) {
   try {
-    const common = await commonServiceContext(options, "forms");
-    if (common) {
+    const common = await commonServiceContext(
+      options,
+      "forms",
+      options.selectedEnvironment
+    );
+    if (!common)
+      throw new SiteOSAuthApiError({
+        code: "PROJECT_REQUIRED",
+        message: "Select a Project with `siteos project use <id-or-slug>`."
+      });
+    {
       if (!options.fetchImpl)
         throw new SiteOSAuthApiError({
           code: "AUTH_UNAVAILABLE",
           message: "SiteOS API access is unavailable."
         });
-      const grant2 = await serviceGrantProvider(options).acquire({
+      const grant = await serviceGrantProvider(options).acquire({
         audience: "siteos-forms",
         scopes: [scope]
       });
-      requireGrant(grant2, scope);
-      if (grant2.grant.organizationId !== common.overview.project.organizationId)
+      requireGrant(grant, scope);
+      if (grant.grant.organizationId !== common.overview.project.organizationId)
         throw new SiteOSAuthApiError({
           code: "PROJECT_ORGANIZATION_MISMATCH",
           message: "The Project and service grant belong to different organizations."
         });
       return {
         commonProjectId: common.overview.project.id,
+        environmentSlug: common.environment.slug,
         apiBaseUrl: common.api.origin,
         client: createSiteOSFormsApiClient({
           apiBaseUrl: common.api.origin,
           fetchImpl: options.fetchImpl
         }),
-        grant: grant2.accessToken,
+        grant: grant.accessToken,
         ok: true,
         organization: { id: common.overview.project.organizationId },
         project: {
@@ -4277,73 +3732,10 @@ async function loadFormsManagementContext(options, scope) {
         rootDir: common.rootDir
       };
     }
-    const reference = await requireFormsProjectReference(
-      options.cwd ?? process.cwd()
-    );
-    if (!options.fetchImpl) {
-      throw new SiteOSFormsApiError({
-        code: "FORMS_UNAVAILABLE",
-        message: "SiteOS Forms access is unavailable in this runtime."
-      });
-    }
-    const apiBaseUrl = resolveSiteOSFormsBaseUrl(options.env);
-    const binding = await projectBindingStore(options).read({
-      apiOrigin: apiBaseUrl,
-      repositoryRoot: reference.rootDir,
-      service: "forms"
-    });
-    if (!binding) {
-      throw new FormsProjectReferenceError(
-        "FORMS_PROJECT_REFERENCE_REQUIRED",
-        "Select a Forms Project for this repository first."
-      );
-    }
-    const grant = await serviceGrantProvider(options).acquire({
-      audience: "siteos-forms",
-      scopes: [scope]
-    });
-    if (grant.grant.audience !== "siteos-forms" || grant.grant.scopes.length !== 1 || grant.grant.scopes[0] !== scope) {
-      throw new SiteOSAuthApiError({
-        code: "AUTH_INVALID_RESPONSE",
-        message: "The SiteOS Auth service returned an invalid response."
-      });
-    }
-    if (grant.grant.organizationId !== binding.organizationId || binding.project.slug !== reference.reference.project.slug) {
-      throw new SiteOSAuthApiError({
-        code: "AUTH_INVALID_RESPONSE",
-        message: "The selected Forms Project does not match this Auth Organization."
-      });
-    }
-    return {
-      apiBaseUrl,
-      client: createSiteOSFormsApiClient({
-        apiBaseUrl,
-        fetchImpl: options.fetchImpl
-      }),
-      grant: grant.accessToken,
-      ok: true,
-      organization: { id: binding.organizationId },
-      project: {
-        id: binding.project.id,
-        name: reference.reference.project.name,
-        slug: binding.project.slug
-      },
-      rootDir: reference.rootDir
-    };
   } catch (error) {
     return { error: formatManagementContextError(error), ok: false };
   }
 }
-async function requireFormsProjectReference(cwd) {
-  const reference = await inspectFormsProjectReference(cwd);
-  if (reference.status === "missing") {
-    throw new FormsProjectReferenceError(
-      "FORMS_PROJECT_REFERENCE_REQUIRED",
-      "Select a Forms Project for this repository first."
-    );
-  }
-  return reference;
-}
 async function runDefinitionCommand(options) {
   if (["list", "read", "archive", "restore", "delete"].includes(
     options.args[0] ?? ""
@@ -4421,7 +3813,7 @@ async function runDefinitionLifecycle(options) {
     );
     if (!environment)
       return usageError2(
-        "The selected Forms Environment does not exist. Run forms environment list."
+        "The selected Forms Environment does not exist. Run siteos project environment list."
       );
     const input = {
       grant: context.grant,
@@ -4647,41 +4039,20 @@ async function loadSubmissionFormsContext(options) {
   }
   try {
     const common = await readLocalCommonProject(options);
-    if (common)
+    if (common && common.binding.environmentSlug)
       return {
         apiBaseUrl: common.api.origin,
         commonProjectId: common.binding.project.id,
+        environmentSlug: common.binding.environmentSlug,
         ok: true,
         organization: { id: common.binding.organizationId },
         project: { slug: common.binding.project.slug },
         credential
       };
-    const reference = await requireFormsProjectReference(
-      options.cwd ?? process.cwd()
-    );
-    const apiBaseUrl = resolveSiteOSFormsBaseUrl(options.env);
-    const binding = await projectBindingStore(options).read({
-      apiOrigin: apiBaseUrl,
-      repositoryRoot: reference.rootDir,
-      service: "forms"
+    throw new SiteOSAuthApiError({
+      code: "PROJECT_REQUIRED",
+      message: "Select a Project with `siteos project use <id-or-slug>`."
     });
-    if (!binding || binding.project.slug !== reference.reference.project.slug) {
-      throw new FormsProjectReferenceError(
-        binding ? "FORMS_PROJECT_REFERENCE_INVALID" : "FORMS_PROJECT_REFERENCE_REQUIRED",
-        binding ? "The Forms Project reference and private binding do not match." : "Select a Forms Project for this repository first."
-      );
-    }
-    return {
-      apiBaseUrl,
-      ok: true,
-      organization: { id: binding.organizationId },
-      project: {
-        id: binding.project.id,
-        name: reference.reference.project.name,
-        slug: binding.project.slug
-      },
-      credential
-    };
   } catch (error) {
     return { error: formatManagementContextError(error), ok: false };
   }
@@ -4709,76 +4080,6 @@ function formatAuthError(error) {
     ok: false
   };
 }
-function parseProjectFlags(action, args2) {
-  const creates = action === "create";
-  const uses = action === "use";
-  const parsed = parseFlags(args2, {
-    allowed: /* @__PURE__ */ new Set([
-      JSON_FLAG,
-      ...creates ? [NAME_FLAG, SLUG_FLAG] : [],
-      ...uses ? [REPLACE_FLAG] : []
-    ]),
-    boolean: /* @__PURE__ */ new Set([JSON_FLAG, REPLACE_FLAG]),
-    rejectDuplicates: true
-  });
-  if (!parsed.ok) return { error: usageError2(parsed.error), ok: false };
-  if (uses) {
-    if (parsed.positionals.length !== 1) {
-      return {
-        error: usageError2("Project use requires exactly one Project slug."),
-        ok: false
-      };
-    }
-    const slug3 = projectSlugSchema.safeParse(parsed.positionals[0]);
-    if (!slug3.success) {
-      return { error: usageError2("Project slug is invalid."), ok: false };
-    }
-    return {
-      json: parsed.flags.has(JSON_FLAG),
-      ok: true,
-      replace: parsed.flags.has(REPLACE_FLAG),
-      slug: slug3.data
-    };
-  }
-  if (parsed.positionals.length > 0) {
-    return {
-      error: usageError2(`Unexpected argument: ${parsed.positionals[0]}`),
-      ok: false
-    };
-  }
-  if (!creates) {
-    return {
-      json: parsed.flags.has(JSON_FLAG),
-      ok: true,
-      replace: false
-    };
-  }
-  const slug2 = projectSlugSchema.safeParse(
-    readStringFlag(parsed.flags, SLUG_FLAG)
-  );
-  const name = environmentNameSchema.safeParse(
-    readStringFlag(parsed.flags, NAME_FLAG)
-  );
-  if (!slug2.success) {
-    return {
-      error: usageError2("--slug is required and must be valid."),
-      ok: false
-    };
-  }
-  if (!name.success) {
-    return {
-      error: usageError2("--name is required and must be valid."),
-      ok: false
-    };
-  }
-  return {
-    json: parsed.flags.has(JSON_FLAG),
-    name: name.data,
-    ok: true,
-    replace: false,
-    slug: slug2.data
-  };
-}
 function parseCredentialFlags(action, args2) {
   const installs = action === "issue" || action === "rotate";
   const revokes = action === "revoke";
@@ -4847,48 +4148,6 @@ function parseCredentialFlags(action, args2) {
     ok: true
   };
 }
-function parseEnvironmentFlags(action, args2) {
-  const creates = action === "create";
-  const parsed = parseFlags(args2, {
-    allowed: /* @__PURE__ */ new Set([JSON_FLAG, ...creates ? [NAME_FLAG, SLUG_FLAG] : []]),
-    boolean: /* @__PURE__ */ new Set([JSON_FLAG]),
-    rejectDuplicates: true
-  });
-  if (!parsed.ok) return { error: usageError2(parsed.error), ok: false };
-  if (parsed.positionals.length > 0) {
-    return {
-      error: usageError2(`Unexpected argument: ${parsed.positionals[0]}`),
-      ok: false
-    };
-  }
-  if (!creates) {
-    return { json: parsed.flags.has(JSON_FLAG), ok: true };
-  }
-  const slug2 = readStringFlag(parsed.flags, SLUG_FLAG);
-  if (!slug2) {
-    return { error: usageError2("--slug is required."), ok: false };
-  }
-  if (!isValidEnvironmentSlug(slug2)) {
-    return {
-      error: usageError2("--slug must be a valid environment slug."),
-      ok: false
-    };
-  }
-  const name = readStringFlag(parsed.flags, NAME_FLAG);
-  if (!name) {
-    return { error: usageError2("--name is required."), ok: false };
-  }
-  const parsedName = environmentNameSchema.safeParse(name);
-  if (!parsedName.success) {
-    return { error: usageError2("--name is invalid."), ok: false };
-  }
-  return {
-    json: parsed.flags.has(JSON_FLAG),
-    name: parsedName.data,
-    ok: true,
-    slug: slug2
-  };
-}
 function parseDefinitionSourceFlags(args2, options) {
   const parsed = parseFlags(args2, {
     allowed: /* @__PURE__ */ new Set([
@@ -4959,7 +4218,7 @@ async function loadFormDefinitions(options) {
       ok: true
     };
   }
-  const manifestPath = path12.resolve(
+  const manifestPath = path10.resolve(
     options.cwd ?? process.cwd(),
     options.source.path
   );
@@ -4969,10 +4228,10 @@ async function loadFormDefinitions(options) {
     schema: definitionManifestSchema
   });
   if (!manifest.ok) return manifest;
-  const manifestDirectory = path12.dirname(manifestPath);
+  const manifestDirectory = path10.dirname(manifestPath);
   const definitions = [];
   for (const definitionPath of manifest.value.forms) {
-    if (path12.isAbsolute(definitionPath)) {
+    if (path10.isAbsolute(definitionPath)) {
       return {
         error: usageError2(
           `Manifest definition paths must be relative: ${definitionPath}`
@@ -4980,9 +4239,9 @@ async function loadFormDefinitions(options) {
         ok: false
       };
     }
-    const resolvedPath = path12.resolve(manifestDirectory, definitionPath);
-    const relativePath = path12.relative(manifestDirectory, resolvedPath);
-    if (relativePath.startsWith(`..${path12.sep}`) || relativePath === "..") {
+    const resolvedPath = path10.resolve(manifestDirectory, definitionPath);
+    const relativePath = path10.relative(manifestDirectory, resolvedPath);
+    if (relativePath.startsWith(`..${path10.sep}`) || relativePath === "..") {
       return {
         error: usageError2(
           `Manifest definition paths must stay inside the manifest directory: ${definitionPath}`
@@ -5045,7 +4304,7 @@ function parseInputFlags(args2, options) {
   };
 }
 async function readInputFile(options) {
-  const resolvedInputPath = path12.resolve(
+  const resolvedInputPath = path10.resolve(
     options.cwd ?? process.cwd(),
     options.inputPath
   );
@@ -5187,7 +4446,7 @@ function formatCredentialError(error) {
       stderr: error.message
     };
   }
-  if (error instanceof FormsProjectReferenceError || error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
+  if (error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
     return {
       exitCode: 1,
       stderr: [
@@ -5216,7 +4475,7 @@ function formatManagementContextError(error) {
   if (error instanceof SiteOSAuthApiError) {
     return formatAuthError(error).error;
   }
-  if (error instanceof FormsProjectReferenceError || error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
+  if (error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
     return {
       exitCode: 1,
       stderr: [
@@ -5228,24 +4487,12 @@ function formatManagementContextError(error) {
   }
   return formatApiError(error);
 }
-function formatProjectError(error) {
-  if (error instanceof SiteOSAuthApiError) return formatAuthError(error).error;
-  return formatManagementContextError(error);
-}
 function serviceGrantProvider(options) {
   return options.serviceGrantProvider ?? createSiteOSServiceGrantProvider({
     env: options.env,
     fetchImpl: options.fetchImpl
   });
 }
-function projectBindingStore(options) {
-  return options.projectBindingStore ?? new NodeProjectBindingStore(
-    path12.join(
-      resolveSiteOSConfigHome({ env: options.env }),
-      "project-bindings.json"
-    )
-  );
-}
 function requireGrant(grant, scope) {
   if (grant.grant.audience !== "siteos-forms" || grant.grant.scopes.length !== 1 || grant.grant.scopes[0] !== scope) {
     throw new SiteOSAuthApiError({
@@ -5254,23 +4501,6 @@ function requireGrant(grant, scope) {
     });
   }
 }
-function requireProjectOrganization(projects, organizationId) {
-  if (projects.some((project) => project.organizationId !== organizationId)) {
-    throw new SiteOSFormsApiError({
-      code: "INVALID_RESPONSE",
-      message: "SiteOS Forms returned an invalid response."
-    });
-  }
-}
-function formatProjectListOutput(projects) {
-  return [
-    "SiteOS Forms Projects.",
-    `Projects: ${projects.length}`,
-    ...projects.map(
-      (project) => `- ${project.slug}: ${project.name} (${project.id})`
-    )
-  ].join("\n");
-}
 function formatCredentialListOutput(input) {
   return [
     "SiteOS Forms credentials.",
@@ -5281,15 +4511,6 @@ function formatCredentialListOutput(input) {
     )
   ].join("\n");
 }
-function formatEnvironmentListOutput(environments) {
-  return [
-    "SiteOS Forms Environments.",
-    `Environments: ${environments.length}`,
-    ...environments.map(
-      (environment) => `- ${environment.slug}: ${environment.name} (${environment.id})`
-    )
-  ].join("\n");
-}
 function requireEnvironmentProjectConvergence(environments, projectId) {
   if (environments.some((environment) => environment.projectId !== projectId)) {
     throw new SiteOSFormsApiError({
@@ -5322,12 +4543,12 @@ function readOutputString(value) {
 }
 function createFormsUiOutput(input) {
   const commonProjectId = input.context.commonProjectId;
-  const projectId = commonProjectId ?? input.context.project.id;
+  const projectId = commonProjectId;
   if (!projectId) {
     return void 0;
   }
   const url = new URL(
-    commonProjectId ? `/projects/${encodeURIComponent(commonProjectId)}/forms` : `/forms/projects/${encodeURIComponent(projectId)}`,
+    `/projects/${encodeURIComponent(commonProjectId)}/forms?env=${encodeURIComponent(input.context.environmentSlug)}`,
     new URL(input.context.apiBaseUrl).origin
   ).toString();
   return {
@@ -5386,11 +4607,11 @@ async function runDeployment(options) {
 
 // src/package-metadata.ts
 import { readFileSync } from "fs";
-import path13 from "path";
+import path11 from "path";
 import { fileURLToPath } from "url";
 function readPackageMetadata() {
-  const packageJsonPath = path13.resolve(
-    path13.dirname(fileURLToPath(import.meta.url)),
+  const packageJsonPath = path11.resolve(
+    path11.dirname(fileURLToPath(import.meta.url)),
     "..",
     "package.json"
   );
@@ -5404,7 +4625,7 @@ function readPackageMetadata() {
 }
 
 // src/pulse-command.ts
-import path25 from "path";
+import path22 from "path";
 import { parseArgs } from "util";
 
 // src/core/errors.ts
@@ -5417,29 +4638,28 @@ function commandError2(input) {
 
 // src/pulse/api-client.ts
 import { readFile as readFile6 } from "fs/promises";
-import { z as z11 } from "zod";
-var projectSchema = z11.object({
-  baseUrl: z11.string().url().nullable(),
-  checkCount: z11.number().int().min(0),
-  id: z11.string().trim().min(1).max(120),
-  name: z11.string().trim().min(1).max(120),
-  slug: z11.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
+import { z as z9 } from "zod";
+var projectSchema = z9.object({
+  baseUrl: z9.string().url().nullable(),
+  checkCount: z9.number().int().min(0),
+  id: z9.string().trim().min(1).max(120),
+  name: z9.string().trim().min(1).max(120),
+  slug: z9.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
 }).strict();
-var projectListSchema = z11.object({ projects: z11.array(projectSchema) }).strict();
-var projectResponseSchema = z11.object({ project: projectSchema }).strict();
-var deploymentResponseSchema2 = z11.object({
-  checks: z11.array(
-    z11.object({
-      checkId: z11.string().min(1),
-      created: z11.boolean(),
-      deploymentId: z11.string().min(1),
-      slug: z11.string().min(1),
-      version: z11.number().int().positive()
+var projectResponseSchema = z9.object({ project: projectSchema }).strict();
+var deploymentResponseSchema2 = z9.object({
+  checks: z9.array(
+    z9.object({
+      checkId: z9.string().min(1),
+      created: z9.boolean(),
+      deploymentId: z9.string().min(1),
+      slug: z9.string().min(1),
+      version: z9.number().int().positive()
     }).strict()
   ),
-  checksum: z11.string().min(1),
-  dashboardUrl: z11.string().url().optional(),
-  projectId: z11.string().min(1)
+  checksum: z9.string().min(1),
+  dashboardUrl: z9.string().url().nullable().optional(),
+  projectId: z9.string().min(1)
 }).strict();
 function createPulseApiClient(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
@@ -5461,7 +4681,7 @@ function createPulseApiClient(input) {
         "API_UNREACHABLE",
         `Could not reach ${endpoint.origin}.`,
         {
-          hint: "Check SITEOS_PULSE_API_URL and the network connection."
+          hint: "Check SITEOS_AUTH_BASE_URL and the network connection."
         }
       );
     }
@@ -5477,21 +4697,6 @@ function createPulseApiClient(input) {
     return parsed.data;
   };
   return {
-    async createProject(options) {
-      const result = await request({
-        body: JSON.stringify({
-          baseUrl: options.baseUrl,
-          monitoringEnabled: options.monitoringEnabled,
-          name: options.name,
-          slug: options.slug
-        }),
-        grant: options.grant,
-        method: "POST",
-        path: "/api/cli/v1/projects",
-        schema: projectResponseSchema
-      });
-      return result.project;
-    },
     async getProject(options) {
       const result = await request({
         grant: options.grant,
@@ -5500,14 +4705,6 @@ function createPulseApiClient(input) {
       });
       return result.project;
     },
-    async listProjects(options) {
-      const result = await request({
-        grant: options.grant,
-        path: "/api/cli/v1/projects",
-        schema: projectListSchema
-      });
-      return result.projects;
-    },
     async uploadDeployment(options) {
       const form = new FormData();
       const { archivePath: _archivePath, ...publicManifest } = options.manifest;
@@ -5545,122 +4742,23 @@ function pulseApiError(body, status) {
   return new CliError(code, message);
 }
 
-// src/pulse/binding-migration.ts
-import { createHash as createHash5 } from "crypto";
-import { lstat as lstat5, readFile as readFile7, realpath as realpath3 } from "fs/promises";
-import os4 from "os";
-import path14 from "path";
-import { z as z12 } from "zod";
-
-// src/pulse/constants.ts
-var DEFAULT_SITEOS_PULSE_API_URL = "https://app.siteos.sh";
-function normalizeApiUrl(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error(
-      "SiteOS Pulse API URL must be an absolute HTTP or HTTPS URL."
-    );
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new Error("SiteOS Pulse API URL must use HTTP or HTTPS.");
-  }
-  return url.origin;
-}
-
-// src/pulse/binding-migration.ts
-var legacyBindingSchema = z12.object({
-  apiUrl: z12.string().url(),
-  organizationId: z12.string().trim().min(1).max(255),
-  projectId: z12.string().trim().min(1).max(255),
-  projectRoot: z12.string().refine(path14.isAbsolute),
-  projectSlug: z12.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
-}).strict();
-var legacyBindingsSchema = z12.object({
-  bindings: z12.record(legacyBindingSchema),
-  version: z12.literal(2)
-}).strict();
-async function migrateLegacyPulseBinding(input) {
-  const apiOrigin = normalizeApiUrl(input.apiOrigin);
-  const repositoryRoot = await realpath3(path14.resolve(input.repositoryRoot));
-  const locator = { apiOrigin, repositoryRoot, service: "pulse" };
-  const current = await input.projectBindingStore.read(locator);
-  if (current) return { binding: current, status: "already-current" };
-  const legacy = await readLegacyBindings(
-    input.legacyBindingsPath ?? legacyPulseBindingsFilePath()
-  );
-  if (!legacy) return { binding: null, status: "not-found" };
-  const key = legacyBindingKey(apiOrigin, repositoryRoot);
-  const candidate = legacy.bindings[key];
-  if (!candidate || candidate.apiUrl !== apiOrigin || candidate.projectRoot !== repositoryRoot || candidate.organizationId !== input.organizationId || candidate.projectSlug !== input.projectSlug) {
-    return { binding: null, status: "not-found" };
-  }
-  const imported = await input.projectBindingStore.write({
-    ...locator,
-    organizationId: candidate.organizationId,
-    project: { id: candidate.projectId, slug: candidate.projectSlug }
-  });
-  const readBack = await input.projectBindingStore.read(locator);
-  if (!readBack || readBack.project.id !== imported.project.id) {
-    throw new CliError(
-      "PROJECT_BINDING_MIGRATION_FAILED",
-      "The migrated Pulse Project binding could not be verified."
-    );
-  }
-  return { binding: readBack, status: "imported" };
-}
-function legacyPulseBindingsFilePath(input = {}) {
-  const env = input.env ?? process.env;
-  const configRoot = env.XDG_CONFIG_HOME ? path14.resolve(env.XDG_CONFIG_HOME) : path14.join(input.homeDir ?? os4.homedir(), ".config");
-  return path14.join(configRoot, "siteos", "pulse", "project-bindings.json");
-}
-async function readLegacyBindings(filePath) {
-  try {
-    const stats = await lstat5(filePath);
-    if (stats.isSymbolicLink() || !stats.isFile())
-      throw new Error("unsafe file");
-    const parsed = legacyBindingsSchema.parse(
-      JSON.parse(await readFile7(filePath, "utf8"))
-    );
-    for (const [key, binding] of Object.entries(parsed.bindings)) {
-      if (key !== legacyBindingKey(normalizeApiUrl(binding.apiUrl), binding.projectRoot)) {
-        throw new Error("binding key mismatch");
-      }
-    }
-    return parsed;
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw new CliError(
-      "PROJECT_BINDINGS_INVALID",
-      "The legacy Pulse Project bindings could not be read safely.",
-      {
-        hint: "Remove the legacy binding file, then run `siteos pulse project use <slug>`."
-      }
-    );
-  }
-}
-function legacyBindingKey(apiUrl, projectRoot) {
-  return createHash5("sha256").update(`${apiUrl}\0${projectRoot}`).digest("hex");
-}
-
 // src/pulse/bundle.ts
-import { createHash as createHash7, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import {
   access,
   mkdir as mkdir3,
-  readFile as readFile9,
+  readFile as readFile8,
   rename as rename5,
   rm as rm4,
   writeFile as writeFile5
 } from "fs/promises";
-import path16 from "path";
+import path13 from "path";
 import * as tar from "tar";
 
 // src/pulse/project-files.ts
-import { createHash as createHash6 } from "crypto";
-import { lstat as lstat6, readFile as readFile8 } from "fs/promises";
-import path15 from "path";
+import { createHash as createHash5 } from "crypto";
+import { lstat as lstat5, readFile as readFile7 } from "fs/promises";
+import path12 from "path";
 import fg from "fast-glob";
 var MAX_BUNDLE_FILES = 5e3;
 var MAX_BUNDLE_BYTES = 50 * 1024 * 1024;
@@ -5683,7 +4781,7 @@ function isSensitive(relativePath) {
   return SENSITIVE_FILES.some((pattern) => pattern.test(segments.at(-1) ?? ""));
 }
 async function hashFile(filePath) {
-  return createHash6("sha256").update(await readFile8(filePath)).digest("hex");
+  return createHash5("sha256").update(await readFile7(filePath)).digest("hex");
 }
 async function discoverProjectFiles(projectRoot, config) {
   const errors = [];
@@ -5756,13 +4854,13 @@ async function discoverProjectFiles(projectRoot, config) {
       errors.push(`Sensitive path cannot be included: ${relativePath}`);
       continue;
     }
-    const absolutePath = path15.resolve(projectRoot, relativePath);
-    const relativeToRoot = path15.relative(projectRoot, absolutePath);
-    if (relativeToRoot.startsWith("..") || path15.isAbsolute(relativeToRoot)) {
+    const absolutePath = path12.resolve(projectRoot, relativePath);
+    const relativeToRoot = path12.relative(projectRoot, absolutePath);
+    if (relativeToRoot.startsWith("..") || path12.isAbsolute(relativeToRoot)) {
       errors.push(`Included path escapes the project root: ${relativePath}`);
       continue;
     }
-    const stats = await lstat6(absolutePath);
+    const stats = await lstat5(absolutePath);
     if (!stats.isFile()) continue;
     if (stats.size > MAX_FILE_BYTES) {
       errors.push(`File exceeds the 10 MiB limit: ${relativePath}`);
@@ -5778,8 +4876,8 @@ async function discoverProjectFiles(projectRoot, config) {
   if (totalBytes > MAX_BUNDLE_BYTES)
     errors.push("The bundle exceeds the 50 MiB size limit.");
   try {
-    const packageSource = await readFile8(
-      path15.join(projectRoot, "package.json"),
+    const packageSource = await readFile7(
+      path12.join(projectRoot, "package.json"),
       "utf8"
     );
     const packageJson = JSON.parse(packageSource);
@@ -5801,10 +4899,10 @@ async function discoverProjectFiles(projectRoot, config) {
 
 // src/pulse/bundle.ts
 async function hashArchive(archivePath) {
-  return createHash7("sha256").update(await readFile9(archivePath)).digest("hex");
+  return createHash6("sha256").update(await readFile8(archivePath)).digest("hex");
 }
 async function createDeploymentBundle(input) {
-  const projectRoot = path16.resolve(input.projectRoot);
+  const projectRoot = path13.resolve(input.projectRoot);
   const config = await loadChecksConfig(projectRoot);
   const configFile = await findChecksConfigFile(projectRoot) ?? CONFIG_FILE;
   const report = await discoverProjectFiles(projectRoot, config);
@@ -5817,9 +4915,9 @@ async function createDeploymentBundle(input) {
       }
     );
   }
-  const outputDirectory = input.output ? path16.dirname(path16.resolve(projectRoot, input.output)) : path16.join(projectRoot, ".siteos", "pulse", "deployments");
+  const outputDirectory = input.output ? path13.dirname(path13.resolve(projectRoot, input.output)) : path13.join(projectRoot, ".siteos", "pulse", "deployments");
   await mkdir3(outputDirectory, { recursive: true });
-  const temporaryPath = path16.join(
+  const temporaryPath = path13.join(
     outputDirectory,
     `.siteos-pulse-${randomUUID4()}.tgz`
   );
@@ -5838,7 +4936,7 @@ async function createDeploymentBundle(input) {
     archiveFiles
   );
   const checksum2 = await hashArchive(temporaryPath);
-  const archivePath = input.output ? path16.resolve(projectRoot, input.output) : path16.join(outputDirectory, `siteos-pulse-${checksum2.slice(0, 16)}.tgz`);
+  const archivePath = input.output ? path13.resolve(projectRoot, input.output) : path13.join(outputDirectory, `siteos-pulse-${checksum2.slice(0, 16)}.tgz`);
   try {
     await access(archivePath);
     if (input.output) {
@@ -5878,13 +4976,13 @@ async function createDeploymentBundle(input) {
 }
 
 // src/pulse/init.ts
-import { mkdir as mkdir4, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import path14 from "path";
 var SITEOS_PLAYWRIGHT_CONFIG = "siteos.playwright.config.ts";
 var PULSE_CACHE_DIRECTORY = ".siteos/pulse/";
 async function exists(filePath) {
   try {
-    await readFile10(filePath);
+    await readFile9(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -5919,7 +5017,7 @@ export default defineConfig({
 `;
 }
 async function createPulsePlaywrightConfig(input) {
-  const configPath = path17.join(input.projectRoot, SITEOS_PLAYWRIGHT_CONFIG);
+  const configPath = path14.join(input.projectRoot, SITEOS_PLAYWRIGHT_CONFIG);
   if (await exists(configPath)) {
     throw new CliError(
       "PULSE_PLAYWRIGHT_CONFIG_EXISTS",
@@ -5936,21 +5034,21 @@ async function createPulsePlaywrightConfig(input) {
 }
 async function detectPackageName(projectRoot) {
   try {
-    const contents = await readFile10(
-      path17.join(projectRoot, "package.json"),
+    const contents = await readFile9(
+      path14.join(projectRoot, "package.json"),
       "utf8"
     );
     const parsed = JSON.parse(contents);
-    return typeof parsed.name === "string" ? parsed.name : path17.basename(projectRoot);
+    return typeof parsed.name === "string" ? parsed.name : path14.basename(projectRoot);
   } catch {
-    return path17.basename(projectRoot);
+    return path14.basename(projectRoot);
   }
 }
 async function ensureGitignore(projectRoot) {
-  const gitignorePath = path17.join(projectRoot, ".gitignore");
+  const gitignorePath = path14.join(projectRoot, ".gitignore");
   let contents = "";
   try {
-    contents = await readFile10(gitignorePath, "utf8");
+    contents = await readFile9(gitignorePath, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
@@ -5965,21 +5063,21 @@ async function ensureGitignore(projectRoot) {
   return true;
 }
 async function initializeProject(input) {
-  const projectRoot = path17.resolve(input.projectRoot);
+  const projectRoot = path14.resolve(input.projectRoot);
   const existingConfig = await findChecksConfigFile(projectRoot);
   if (existingConfig) {
     throw new CliError("CONFIG_EXISTS", `${existingConfig} already exists.`, {
       hint: "Edit the existing file or run `siteos pulse validate`."
     });
   }
-  const configPath = path17.join(projectRoot, CONFIG_FILE);
+  const configPath = path14.join(projectRoot, CONFIG_FILE);
   const created = [];
   const updated = [];
   const testsDir = input.testsDir ?? "tests/siteos";
   const packageName2 = await detectPackageName(projectRoot);
   const projectName = projectDisplayName(input.project ?? packageName2);
   const checkSlug = projectSlug(input.suite ?? "homepage");
-  const exampleTest = path17.posix.join(
+  const exampleTest = path14.posix.join(
     testsDir.replaceAll("\\", "/"),
     `${checkSlug}.spec.ts`
   );
@@ -5992,7 +5090,6 @@ async function initializeProject(input) {
       monitoringEnabled: true
     },
     testsDir,
-    apiUrl: DEFAULT_SITEOS_PULSE_API_URL,
     playwrightConfig: SITEOS_PLAYWRIGHT_CONFIG,
     checks: [
       {
@@ -6017,11 +5114,11 @@ async function initializeProject(input) {
     baseUrl: input.baseUrl
   });
   created.push(SITEOS_PLAYWRIGHT_CONFIG);
-  const testDirectory = path17.join(projectRoot, testsDir);
+  const testDirectory = path14.join(projectRoot, testsDir);
   await mkdir4(testDirectory, { recursive: true });
-  if (!await exists(path17.join(projectRoot, exampleTest))) {
+  if (!await exists(path14.join(projectRoot, exampleTest))) {
     await writeFile6(
-      path17.join(projectRoot, exampleTest),
+      path14.join(projectRoot, exampleTest),
       `import { expect, test } from "@playwright/test";
 
 test(${JSON.stringify(`${projectDisplayName(input.suite ?? "homepage")} is reachable`)}, async ({ page }) => {
@@ -6047,14 +5144,14 @@ test(${JSON.stringify(`${projectDisplayName(input.suite ?? "homepage")} is reach
 import fg4 from "fast-glob";
 
 // src/pulse/interactive/discovery.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { createRequire } from "module";
-import path19 from "path";
+import path16 from "path";
 import fg2 from "fast-glob";
 
 // src/pulse/interactive/playwright-config.ts
-import { readFile as readFile11 } from "fs/promises";
-import path18 from "path";
+import { readFile as readFile10 } from "fs/promises";
+import path15 from "path";
 
 // src/pulse/interactive/discovery.ts
 var PLAYWRIGHT_SPEC_PATTERN = "**/*.{spec,test}.{js,cjs,mjs,ts,cts,mts,jsx,tsx}";
@@ -6099,11 +5196,11 @@ async function discoverPlaywrightSelectorMatches(projectRoot, selectors, testsDi
 }
 
 // src/pulse/sync-plan.ts
-import path20 from "path";
+import path17 from "path";
 import fg3 from "fast-glob";
 var PLAYWRIGHT_SPEC_FILE = /\.(?:spec|test)\.(?:[cm]?[jt]sx?)$/;
 function defaultNameFromSpec(specPath) {
-  const basename = path20.posix.basename(specPath).replace(/\.(?:spec|test)\.[^.]+$/, "");
+  const basename = path17.posix.basename(specPath).replace(/\.(?:spec|test)\.[^.]+$/, "");
   return basename.split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" ") || "Smoke";
 }
 function normalizedPaths(paths) {
@@ -6161,8 +5258,8 @@ function buildSyncPlan(input) {
 
 // src/pulse/test-imports.ts
 import { builtinModules } from "module";
-import { readFile as readFile13 } from "fs/promises";
-import path21 from "path";
+import { readFile as readFile12 } from "fs/promises";
+import path18 from "path";
 import { build } from "esbuild";
 var ALLOWED_PACKAGES = /* @__PURE__ */ new Set(["@playwright/test"]);
 var BUILTINS = /* @__PURE__ */ new Set([
@@ -6176,9 +5273,9 @@ function packageName(importPath) {
   return importPath.split("/")[0] ?? importPath;
 }
 function normalizedRelativePath(projectRoot, inputPath) {
-  const absolute = path21.isAbsolute(inputPath) ? inputPath : path21.resolve(projectRoot, inputPath);
-  const relative = path21.relative(projectRoot, absolute).replaceAll("\\", "/");
-  if (!relative || relative.startsWith("../") || path21.isAbsolute(relative)) {
+  const absolute = path18.isAbsolute(inputPath) ? inputPath : path18.resolve(projectRoot, inputPath);
+  const relative = path18.relative(projectRoot, absolute).replaceAll("\\", "/");
+  if (!relative || relative.startsWith("../") || path18.isAbsolute(relative)) {
     throw new CliError(
       "IMPORT_OUTSIDE_PROJECT",
       `A selected test imports outside the project: ${inputPath}`
@@ -6187,7 +5284,7 @@ function normalizedRelativePath(projectRoot, inputPath) {
   return relative;
 }
 async function analyzeTestImports(input) {
-  const projectRoot = path21.resolve(input.projectRoot);
+  const projectRoot = path18.resolve(input.projectRoot);
   const entryFiles = [
     ...new Set(
       input.entryFiles.map((file) => normalizedRelativePath(projectRoot, file))
@@ -6246,7 +5343,7 @@ async function analyzeTestImports(input) {
   const compatibilityIssues = /* @__PURE__ */ new Set();
   await Promise.all(
     inputs.map(async (file) => {
-      const source = await readFile13(path21.join(projectRoot, file), "utf8").catch(
+      const source = await readFile12(path18.join(projectRoot, file), "utf8").catch(
         () => ""
       );
       for (const match of source.matchAll(ENVIRONMENT_PATTERN)) {
@@ -6689,12 +5786,12 @@ async function runSyncCli(input) {
 // src/pulse/playwright.ts
 import { spawn as spawn3 } from "child_process";
 import { createRequire as createRequire2 } from "module";
-import path23 from "path";
+import path20 from "path";
 
 // src/pulse/package-manager.ts
 import { spawn as spawn2 } from "child_process";
-import { access as access2, readFile as readFile14 } from "fs/promises";
-import path22 from "path";
+import { access as access2, readFile as readFile13 } from "fs/promises";
+import path19 from "path";
 var LOCKFILES = [
   { packageManager: "pnpm", filenames: ["pnpm-lock.yaml"] },
   { packageManager: "yarn", filenames: ["yarn.lock"] },
@@ -6716,7 +5813,7 @@ async function fileExists2(filePath) {
 async function declaredPackageManager(projectRoot) {
   let contents;
   try {
-    contents = await readFile14(path22.join(projectRoot, "package.json"), "utf8");
+    contents = await readFile13(path19.join(projectRoot, "package.json"), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -6753,7 +5850,7 @@ async function declaredPackageManager(projectRoot) {
   );
 }
 async function detectPackageManager(projectRoot) {
-  const root = path22.resolve(projectRoot);
+  const root = path19.resolve(projectRoot);
   const declared = await declaredPackageManager(root);
   if (declared) return declared;
   const matches = (await Promise.all(
@@ -6762,7 +5859,7 @@ async function detectPackageManager(projectRoot) {
       filenames: (await Promise.all(
         filenames2.map(async (filename) => ({
           filename,
-          exists: await fileExists2(path22.join(root, filename))
+          exists: await fileExists2(path19.join(root, filename))
         }))
       )).filter((entry) => entry.exists).map((entry) => entry.filename)
     }))
@@ -6823,12 +5920,12 @@ function isMissingBrowserDiagnostic(output) {
 function resolvePlaywrightCli(projectRoot) {
   try {
     const requireFromProject = createRequire2(
-      path23.join(projectRoot, "package.json")
+      path20.join(projectRoot, "package.json")
     );
     const packageJson = requireFromProject.resolve(
       "@playwright/test/package.json"
     );
-    return path23.join(path23.dirname(packageJson), "cli.js");
+    return path20.join(path20.dirname(packageJson), "cli.js");
   } catch {
     throw new CliError(
       "PLAYWRIGHT_NOT_INSTALLED",
@@ -6840,7 +5937,7 @@ function resolvePlaywrightCli(projectRoot) {
   }
 }
 async function runProjectTests(input) {
-  const projectRoot = path23.resolve(input.projectRoot);
+  const projectRoot = path20.resolve(input.projectRoot);
   const config = await loadChecksConfig(projectRoot);
   const report = await discoverProjectFiles(projectRoot, config);
   if (!report.valid) {
@@ -6897,9 +5994,9 @@ async function runProjectTests(input) {
 }
 
 // src/pulse/validate.ts
-import path24 from "path";
+import path21 from "path";
 async function validateProject(projectRoot) {
-  const root = path24.resolve(projectRoot);
+  const root = path21.resolve(projectRoot);
   const config = await loadChecksConfig(root);
   return discoverProjectFiles(root, config);
 }
@@ -6908,10 +6005,6 @@ async function validateProject(projectRoot) {
 var HELP_FLAGS3 = /* @__PURE__ */ new Set(["--help", "-h"]);
 var PULSE_SCOPE = "pulse:workspace:write";
 var PULSE_HELP = `Usage:
-  siteos pulse project list [--json]
-  siteos pulse project create --slug <slug> --name <name> [--json]
-  siteos pulse project use <slug> [--replace] [--json]
-  siteos pulse project status [--json]
   siteos pulse init [--project <slug>] [--suite <slug>] [--tests-dir <path>] [--base-url <url>]
   siteos pulse validate [--json]
   siteos pulse sync [--check] [--json]
@@ -6925,8 +6018,6 @@ async function runPulseCommand(options) {
   }
   try {
     const [command2, ...args2] = options.args;
-    if (command2 === "project")
-      return await runProjectCommand2({ ...options, args: args2 });
     if (command2 === "init") return await runInitCommand(options, args2);
     if (command2 === "validate") return await runValidateCommand(options, args2);
     if (command2 === "sync") return await runSyncCommand(options, args2);
@@ -6937,130 +6028,6 @@ async function runPulseCommand(options) {
     return formatPulseError(error, options.args.includes("--json"));
   }
 }
-async function runProjectCommand2(options) {
-  const [action, ...args2] = options.args;
-  if (!action || !["create", "list", "status", "use"].includes(action)) {
-    throw usageError3("Unknown SiteOS Pulse project command.");
-  }
-  const parsed = parseProjectArguments(action, args2);
-  const cwd = options.cwd ?? process.cwd();
-  const root = action === "list" ? null : await findRepositoryRoot(cwd);
-  const apiOrigin = await resolvePulseApiOrigin({
-    cwd: root ?? cwd,
-    env: options.env,
-    requireConfig: action !== "list"
-  });
-  const grant = await acquirePulseGrant(options);
-  const client = createPulseApiClient({
-    apiOrigin,
-    fetchImpl: options.fetchImpl
-  });
-  if (action === "list") {
-    const projects = await client.listProjects({ grant: grant.accessToken });
-    return success(
-      parsed.json,
-      { apiOrigin, organizationId: grant.grant.organizationId, projects },
-      formatProjectList(projects)
-    );
-  }
-  const repositoryRoot = root;
-  const snapshot = await loadChecksConfigSnapshot(repositoryRoot);
-  if (action === "create") {
-    const baseUrl = snapshot.config.project.baseUrl;
-    if (!baseUrl) {
-      throw new CliError(
-        "PULSE_PROJECT_BASE_URL_REQUIRED",
-        "Set project.baseUrl in siteos.config.json before creating the Pulse Project."
-      );
-    }
-    const project = await client.createProject({
-      baseUrl,
-      grant: grant.accessToken,
-      monitoringEnabled: snapshot.config.project.monitoringEnabled,
-      name: parsed.name,
-      slug: parsed.slug
-    });
-    return success(
-      parsed.json,
-      { apiOrigin, project },
-      [
-        "SiteOS Pulse Project created.",
-        `Project: ${project.slug}`,
-        `Name: ${project.name}`,
-        `Run \`siteos pulse project use ${project.slug}\` to select it for this repository.`
-      ].join("\n")
-    );
-  }
-  const store = projectBindingStore2(options);
-  const locator = { apiOrigin, repositoryRoot, service: "pulse" };
-  if (action === "use") {
-    const projects = await client.listProjects({ grant: grant.accessToken });
-    const project = uniqueProjectBySlug(projects, parsed.slug);
-    const previous = await store.read(locator);
-    const replacing = snapshot.config.project.slug !== project.slug || previous !== null && previous.project.id !== project.id;
-    if (replacing && !parsed.replace) {
-      throw new CliError(
-        "PULSE_PROJECT_REFERENCE_CONFLICT",
-        "A different Pulse Project is already selected. Use --replace to replace it."
-      );
-    }
-    await store.write({
-      ...locator,
-      organizationId: grant.grant.organizationId,
-      project: { id: project.id, slug: project.slug }
-    });
-    try {
-      await reconcileProjectSlug(repositoryRoot, project.slug, {
-        expectedChecksum: snapshot.checksum
-      });
-    } catch (error) {
-      if (previous) await store.write(previous);
-      else await store.remove(locator);
-      throw error;
-    }
-    return success(
-      parsed.json,
-      {
-        apiOrigin,
-        organizationId: grant.grant.organizationId,
-        project,
-        referencePath: path25.join(repositoryRoot, CONFIG_FILE)
-      },
-      [
-        "SiteOS Pulse Project selected.",
-        `Project: ${project.slug}`,
-        `Reference: ${path25.join(repositoryRoot, CONFIG_FILE)}`
-      ].join("\n")
-    );
-  }
-  const selected = await requireSelectedProject({
-    options,
-    apiOrigin,
-    client,
-    grant,
-    legacyBindingsPath: options.legacyBindingsPath,
-    projectBindingStore: store,
-    projectSlug: snapshot.config.project.slug,
-    repositoryRoot
-  });
-  return success(
-    parsed.json,
-    {
-      apiOrigin,
-      connected: true,
-      migration: selected.migration,
-      organizationId: grant.grant.organizationId,
-      project: selected.project,
-      repositoryRoot
-    },
-    [
-      "SiteOS Pulse Project connection is valid.",
-      `Project: ${selected.project.slug}`,
-      `Organization: ${grant.grant.organizationId}`,
-      `API: ${apiOrigin}`
-    ].join("\n")
-  );
-}
 async function runInitCommand(options, args2) {
   const { values } = parseArgs({
     args: args2,
@@ -7179,7 +6146,7 @@ async function runDeployCommand(options, args2) {
     },
     strict: true
   });
-  const projectRoot = path25.resolve(options.cwd ?? process.cwd());
+  const projectRoot = path22.resolve(options.cwd ?? process.cwd());
   const repositoryRoot = await findRepositoryRoot(projectRoot);
   const common = await commonServiceContext(options, "pulse");
   if (common && (!common.environmentBinding?.slug || !common.environment.url))
@@ -7203,18 +6170,19 @@ async function runDeployCommand(options, args2) {
       values.json,
       { dryRun: true, manifest },
       [
-        `Bundle: ${path25.relative(projectRoot, manifest.archivePath)}`,
+        `Bundle: ${path22.relative(projectRoot, manifest.archivePath)}`,
         `Checksum: ${manifest.checksum}`,
         `Files: ${manifest.fileCount}`,
         "Dry run complete; nothing was uploaded."
       ].join("\n")
     );
   }
-  const apiOrigin = await resolvePulseApiOrigin({
-    cwd: projectRoot,
-    env: options.env,
-    requireConfig: true
-  });
+  if (!common)
+    throw new CliError(
+      "PROJECT_REQUIRED",
+      "Select a Project with `siteos project use <id-or-slug>` before deploying."
+    );
+  const apiOrigin = common.api.origin;
   const grant = await acquirePulseGrant(options);
   const client = createPulseApiClient({
     apiOrigin,
@@ -7226,8 +6194,6 @@ async function runDeployCommand(options, args2) {
     apiOrigin,
     client,
     grant,
-    legacyBindingsPath: options.legacyBindingsPath,
-    projectBindingStore: projectBindingStore2(options),
     projectSlug: snapshot.config.project.slug,
     repositoryRoot
   });
@@ -7246,7 +6212,7 @@ async function runDeployCommand(options, args2) {
     values.json,
     { deployment, dryRun: false, manifest },
     [
-      `Bundle: ${path25.relative(projectRoot, manifest.archivePath)}`,
+      `Bundle: ${path22.relative(projectRoot, manifest.archivePath)}`,
       `Checksum: ${manifest.checksum}`,
       `Files: ${manifest.fileCount}`,
       `Project ${deployment.projectId} deployed.`,
@@ -7280,124 +6246,22 @@ async function requireSelectedProject(input) {
         "The selected Project and Pulse deployment origin or organization do not match."
       );
     }
-    const project2 = await input.client.getProject({
+    const project = await input.client.getProject({
       grant: input.grant.accessToken,
       projectId: common.resourceId
     });
-    if (project2.slug !== input.projectSlug && common.overview.project.slug !== input.projectSlug)
+    if (project.slug !== input.projectSlug && common.overview.project.slug !== input.projectSlug)
       throw new CliError(
         "PULSE_PROJECT_BINDING_INVALID",
         `Set project.slug in siteos.config.json to ${common.overview.project.slug} before deploying checks to this Project.`
       );
-    return { migration: "not-required", project: project2 };
-  }
-  const migration = await migrateLegacyPulseBinding({
-    apiOrigin: input.apiOrigin,
-    legacyBindingsPath: input.legacyBindingsPath,
-    organizationId: input.grant.grant.organizationId,
-    projectBindingStore: input.projectBindingStore,
-    projectSlug: input.projectSlug,
-    repositoryRoot: input.repositoryRoot
-  });
-  const binding = migration.binding;
-  if (!binding) {
-    throw new CliError(
-      "PULSE_PROJECT_BINDING_REQUIRED",
-      "Select a Pulse Project for this repository first.",
-      { hint: `Run \`siteos pulse project use ${input.projectSlug}\`.` }
-    );
-  }
-  if (binding.organizationId !== input.grant.grant.organizationId || binding.project.slug !== input.projectSlug) {
-    throw new CliError(
-      "PULSE_PROJECT_BINDING_INVALID",
-      "The Pulse Project configuration and private binding do not match.",
-      {
-        hint: `Run \`siteos pulse project use ${input.projectSlug} --replace\`.`
-      }
-    );
-  }
-  const project = await input.client.getProject({
-    grant: input.grant.accessToken,
-    projectId: binding.project.id
-  });
-  if (project.slug !== binding.project.slug) {
-    throw new CliError(
-      "PULSE_PROJECT_BINDING_STALE",
-      "The selected Pulse Project is no longer valid.",
-      {
-        hint: `Run \`siteos pulse project use ${input.projectSlug} --replace\`.`
-      }
-    );
-  }
-  return { migration: migration.status, project };
-}
-async function resolvePulseApiOrigin(input) {
-  const configured = input.env?.SITEOS_PULSE_API_URL?.trim();
-  if (configured) return normalizeApiUrl(configured);
-  try {
-    const config = await loadChecksConfigFile(input.cwd);
-    if (config.apiUrl) return normalizeApiUrl(config.apiUrl);
-  } catch (error) {
-    if (input.requireConfig || !(error instanceof CliError) || error.code !== "CONFIG_NOT_FOUND") {
-      throw error;
-    }
+    return { project };
   }
-  return DEFAULT_SITEOS_PULSE_API_URL;
-}
-function projectBindingStore2(options) {
-  return options.projectBindingStore ?? new NodeProjectBindingStore(
-    path25.join(
-      resolveSiteOSConfigHome({ env: options.env, homeDir: options.homeDir }),
-      "project-bindings.json"
-    )
+  throw new CliError(
+    "PROJECT_REQUIRED",
+    "Select a Project with `siteos project use <id-or-slug>` before deploying."
   );
 }
-function parseProjectArguments(action, args2) {
-  const { positionals, values } = parseArgs({
-    allowPositionals: true,
-    args: args2,
-    options: {
-      json: { default: false, type: "boolean" },
-      ...action === "create" ? {
-        name: { type: "string" },
-        slug: { type: "string" }
-      } : {},
-      ...action === "use" ? { replace: { default: false, type: "boolean" } } : {}
-    },
-    strict: true
-  });
-  if (action === "create" && (!values.slug || !values.name || positionals.length > 0)) {
-    throw usageError3(
-      "Usage: siteos pulse project create --slug <slug> --name <name> [--json]"
-    );
-  }
-  if (action === "use" && (positionals.length !== 1 || !positionals[0])) {
-    throw usageError3(
-      "Usage: siteos pulse project use <slug> [--replace] [--json]"
-    );
-  }
-  if ((action === "list" || action === "status") && positionals.length > 0) {
-    throw usageError3(
-      `siteos pulse project ${action} does not accept positional arguments.`
-    );
-  }
-  return {
-    json: Boolean(values.json),
-    name: typeof values.name === "string" ? values.name : void 0,
-    replace: Boolean(values.replace),
-    slug: action === "use" ? positionals[0] : typeof values.slug === "string" ? values.slug : void 0
-  };
-}
-function uniqueProjectBySlug(projects, slug2) {
-  const matches = projects.filter((project) => project.slug === slug2);
-  if (matches.length !== 1) {
-    throw new CliError(
-      matches.length === 0 ? "PULSE_PROJECT_NOT_FOUND" : "API_INVALID_RESPONSE",
-      matches.length === 0 ? "The Pulse Project was not found." : "SiteOS Pulse returned an ambiguous Project list."
-    );
-  }
-  return matches[0];
-}
 function formatValidation(report) {
   return [
     report.valid ? "SiteOS Pulse project is valid." : "SiteOS Pulse project is invalid.",
@@ -7426,15 +6290,6 @@ function formatSyncReport(report) {
     ...report.blockers.map((blocker) => `Blocker: ${blocker.message}`)
   ].join("\n");
 }
-function formatProjectList(projects) {
-  return [
-    "SiteOS Pulse Projects.",
-    `Projects: ${projects.length}`,
-    ...projects.map(
-      (project) => `- ${project.slug}: ${project.name} (${project.checkCount} Check${project.checkCount === 1 ? "" : "s"})`
-    )
-  ].join("\n");
-}
 function success(json, value, text) {
   return {
     exitCode: CLI_EXIT_CODE.success,
@@ -7496,92 +6351,64 @@ function exitCodeForPulseError(error) {
   return CLI_EXIT_CODE.internal;
 }
 
-// src/search-command.ts
-import path27 from "path";
-
 // src/siteos-search-api.ts
-import { z as z13 } from "zod";
-var DEFAULT_SITEOS_SEARCH_BASE_URL = "https://app.siteos.sh";
-var SITEOS_SEARCH_BASE_URL_ENV = "SITEOS_SEARCH_PUBLIC_URL";
-var permissiveObjectSchema = z13.record(z13.unknown());
-var environmentSlugSchema = z13.string().min(2).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
-var searchProjectSchema = z13.object({
-  createdAt: z13.string().datetime({ offset: true }),
-  id: z13.string().trim().min(1).max(255),
-  name: z13.string().trim().min(1).max(255),
-  organizationId: z13.string().trim().min(1).max(255),
-  slug: z13.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  updatedAt: z13.string().datetime({ offset: true })
-}).strict();
-var searchProjectListResponseSchema = z13.object({ projects: z13.array(searchProjectSchema), success: z13.literal(true) }).strict();
-var searchProjectResponseSchema = z13.object({ project: searchProjectSchema, success: z13.literal(true) }).strict();
-var searchEnvironmentSchema = z13.object({
-  createdAt: z13.string().datetime({ offset: true }),
-  id: z13.string().trim().min(1).max(255),
-  name: z13.string().trim().min(1).max(255),
-  projectId: z13.string().trim().min(1).max(255),
-  slug: environmentSlugSchema,
-  updatedAt: z13.string().datetime({ offset: true })
-}).strict();
-var searchEnvironmentListResponseSchema = z13.object({
-  environments: z13.array(searchEnvironmentSchema),
-  success: z13.literal(true)
-}).strict();
-var searchEnvironmentResponseSchema = z13.object({ environment: searchEnvironmentSchema, success: z13.literal(true) }).passthrough();
-var searchCredentialMetadataSchema = z13.object({
-  createdAt: z13.string().datetime({ offset: true }),
-  id: z13.string().trim().min(1).max(255),
-  lastUsedAt: z13.string().datetime({ offset: true }).nullable(),
-  name: z13.string().trim().min(1).max(255),
-  projectEnvironmentId: z13.string().trim().min(1).max(255),
-  revokedAt: z13.string().datetime({ offset: true }).nullable(),
-  status: z13.enum(["active", "revoked"])
+import { z as z10 } from "zod";
+var permissiveObjectSchema = z10.record(z10.unknown());
+var environmentSlugSchema = z10.string().min(2).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var searchCredentialMetadataSchema = z10.object({
+  createdAt: z10.string().datetime({ offset: true }),
+  id: z10.string().trim().min(1).max(255),
+  lastUsedAt: z10.string().datetime({ offset: true }).nullable(),
+  name: z10.string().trim().min(1).max(255),
+  projectEnvironmentId: z10.string().trim().min(1).max(255),
+  revokedAt: z10.string().datetime({ offset: true }).nullable(),
+  status: z10.enum(["active", "revoked"])
 }).strict();
-var searchCredentialListResponseSchema = z13.object({
+var searchCredentialListResponseSchema = z10.object({
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true),
-  tokens: z13.array(searchCredentialMetadataSchema)
+  success: z10.literal(true),
+  tokens: z10.array(searchCredentialMetadataSchema)
 }).strict();
-var searchCredentialExchangeResponseSchema = z13.object({
+var searchCredentialExchangeResponseSchema = z10.object({
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true),
+  success: z10.literal(true),
   token: searchCredentialMetadataSchema.extend({
-    token: z13.string().regex(/^psq_[A-Za-z0-9_-]{22}$/)
+    token: z10.string().regex(/^psq_[A-Za-z0-9_-]{22}$/)
   })
 }).strict();
-var searchCredentialRevokeResponseSchema = z13.object({
+var searchCredentialRevokeResponseSchema = z10.object({
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true),
+  success: z10.literal(true),
   token: searchCredentialMetadataSchema
 }).strict();
-var searchIndexingCredentialListResponseSchema = z13.object({
-  credentials: z13.array(searchCredentialMetadataSchema),
+var searchIndexingCredentialListResponseSchema = z10.object({
+  credentials: z10.array(searchCredentialMetadataSchema),
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true)
+  success: z10.literal(true)
 }).strict();
-var searchIndexingCredentialExchangeResponseSchema = z13.object({
+var searchIndexingCredentialExchangeResponseSchema = z10.object({
   credential: searchCredentialMetadataSchema.extend({
-    credential: z13.string().regex(/^psi_[A-Za-z0-9_-]{22}$/)
+    credential: z10.string().regex(/^psi_[A-Za-z0-9_-]{22}$/)
   }).strict(),
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true)
+  success: z10.literal(true)
 }).strict();
-var searchIndexingCredentialRevokeResponseSchema = z13.object({
+var searchIndexingCredentialRevokeResponseSchema = z10.object({
   credential: searchCredentialMetadataSchema,
   environmentSlug: environmentSlugSchema,
-  success: z13.literal(true)
+  success: z10.literal(true)
 }).strict();
-var nestedApiErrorResponseSchema = z13.object({
-  error: z13.object({
-    code: z13.string().trim().min(1).optional(),
-    message: z13.string().trim().min(1),
-    nextActions: z13.array(z13.string()).optional()
+var nestedApiErrorResponseSchema = z10.object({
+  error: z10.object({
+    code: z10.string().trim().min(1).optional(),
+    message: z10.string().trim().min(1),
+    nextActions: z10.array(z10.string()).optional()
   })
 }).passthrough();
-var directApiErrorResponseSchema = z13.object({
-  code: z13.string().trim().min(1).optional(),
-  message: z13.string().trim().min(1).optional(),
-  status: z13.number().int().optional()
+var directApiErrorResponseSchema = z10.object({
+  code: z10.string().trim().min(1).optional(),
+  message: z10.string().trim().min(1).optional(),
+  status: z10.number().int().optional()
 }).passthrough();
 var SiteOSSearchApiError = class extends Error {
   code;
@@ -7595,90 +6422,8 @@ var SiteOSSearchApiError = class extends Error {
     this.status = options.status;
   }
 };
-function resolveSiteOSSearchBaseUrl(env = process.env) {
-  return normalizeSearchOrigin(
-    env[SITEOS_SEARCH_BASE_URL_ENV]?.trim() || DEFAULT_SITEOS_SEARCH_BASE_URL
-  );
-}
 function createSiteOSSearchApiClient(options) {
   return {
-    createProject: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        body: { name: input.name, slug: input.slug },
-        fetchImpl: options.fetchImpl,
-        method: "POST",
-        path: "/api/v1/search/projects",
-        responseSchema: searchProjectResponseSchema
-      });
-      return response.project;
-    },
-    listProjects: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        fetchImpl: options.fetchImpl,
-        method: "GET",
-        path: "/api/v1/search/projects",
-        responseSchema: searchProjectListResponseSchema
-      });
-      return response.projects;
-    },
-    listEnvironments: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        fetchImpl: options.fetchImpl,
-        method: "GET",
-        path: environmentCollectionPath2(input.projectId),
-        responseSchema: searchEnvironmentListResponseSchema
-      });
-      return response.environments;
-    },
-    createEnvironment: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        body: { slug: input.slug, name: input.name },
-        fetchImpl: options.fetchImpl,
-        method: "POST",
-        path: environmentCollectionPath2(input.projectId),
-        responseSchema: searchEnvironmentResponseSchema
-      });
-      return response.environment;
-    },
-    updateEnvironment: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        body: { name: input.name },
-        fetchImpl: options.fetchImpl,
-        method: "PATCH",
-        path: environmentPath(input.projectId, input.environmentSlug),
-        responseSchema: searchEnvironmentResponseSchema
-      });
-      return response.environment;
-    },
-    forkEnvironment: async (input) => {
-      const response = await requestJson3({
-        apiBaseUrl: options.apiBaseUrl,
-        authToken: input.token,
-        body: { slug: input.slug, name: input.name },
-        fetchImpl: options.fetchImpl,
-        method: "POST",
-        path: `${environmentPath(input.projectId, input.sourceEnvironmentSlug)}/actions/fork`,
-        responseSchema: searchEnvironmentResponseSchema
-      });
-      return response.environment;
-    },
-    deleteEnvironment: (input) => requestJson3({
-      apiBaseUrl: options.apiBaseUrl,
-      authToken: input.token,
-      fetchImpl: options.fetchImpl,
-      method: "DELETE",
-      path: environmentPath(input.projectId, input.environmentSlug)
-    }),
     analytics: (input) => requestJson3({
       apiBaseUrl: options.apiBaseUrl,
       authToken: input.token,
@@ -7926,36 +6671,19 @@ function buildApiUrl2(options) {
   }
   return url.toString();
 }
-function normalizeSearchOrigin(value) {
-  try {
-    const url = new URL(value);
-    const loopback = ["localhost", "127.0.0.1", "[::1]", "::1"].includes(
-      url.hostname
-    );
-    if (url.username || url.password || url.pathname !== "/" || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
-      throw new Error("invalid Search origin");
-    }
-    return url.origin;
-  } catch {
-    throw new SiteOSSearchApiError({
-      code: "INVALID_SEARCH_BASE_URL",
-      message: "The SiteOS Search URL is invalid."
-    });
-  }
-}
 
 // src/siteos-search-credential.ts
 import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 import {
   chmod as chmod4,
-  lstat as lstat7,
-  readFile as readFile15,
+  lstat as lstat6,
+  readFile as readFile14,
   rename as rename6,
   rm as rm5,
   writeFile as writeFile7
 } from "fs/promises";
-import path26 from "path";
+import path23 from "path";
 var SITEOS_SEARCH_QUERY_CREDENTIAL_ENV = "SITEOS_SEARCH_TOKEN";
 var SITEOS_SEARCH_ENVIRONMENT_ENV = "SITEOS_SEARCH_ENV";
 var SITEOS_SEARCH_INDEXING_CREDENTIAL_ENV = "SITEOS_SEARCH_INDEXING_CREDENTIAL";
@@ -7973,8 +6701,8 @@ var SiteOSSearchCredentialStorageError = class extends Error {
   }
 };
 async function prepareSiteOSSearchCredentialInstallation(options) {
-  const projectRoot = path26.resolve(options.projectRoot);
-  const dotenvPath = path26.join(projectRoot, ".env");
+  const projectRoot = path23.resolve(options.projectRoot);
+  const dotenvPath = path23.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot2(projectRoot);
     if (!await isDotenvIgnored2(projectRoot)) {
@@ -8032,8 +6760,8 @@ async function prepareSiteOSSearchCredentialInstallation(options) {
   }
 }
 async function prepareSiteOSSearchIndexingCredentialInstallation(options) {
-  const projectRoot = path26.resolve(options.projectRoot);
-  const dotenvPath = path26.join(projectRoot, ".env");
+  const projectRoot = path23.resolve(options.projectRoot);
+  const dotenvPath = path23.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot2(projectRoot);
     if (!await isDotenvIgnored2(projectRoot)) {
@@ -8092,7 +6820,7 @@ async function prepareSiteOSSearchIndexingCredentialInstallation(options) {
   }
 }
 async function assertSafeProjectRoot2(projectRoot) {
-  const projectStats = await lstat7(projectRoot);
+  const projectStats = await lstat6(projectRoot);
   if (!projectStats.isDirectory() || projectStats.isSymbolicLink()) {
     throw new SiteOSSearchCredentialStorageError(
       "SEARCH_CREDENTIAL_STORAGE_INVALID"
@@ -8100,7 +6828,7 @@ async function assertSafeProjectRoot2(projectRoot) {
   }
 }
 async function readSafeDotenv2(dotenvPath, managedEnvironmentNames) {
-  const dotenvStats = await lstat7(dotenvPath).catch((error) => {
+  const dotenvStats = await lstat6(dotenvPath).catch((error) => {
     if (isNodeErrorCode5(error, "ENOENT")) return void 0;
     throw error;
   });
@@ -8109,7 +6837,7 @@ async function readSafeDotenv2(dotenvPath, managedEnvironmentNames) {
       "SEARCH_CREDENTIAL_STORAGE_INVALID"
     );
   }
-  const content = dotenvStats ? await readFile15(dotenvPath, "utf8") : "";
+  const content = dotenvStats ? await readFile14(dotenvPath, "utf8") : "";
   if (managedEnvironmentNames.some(
     (name) => countManagedEntries(content, name) > 1
   )) {
@@ -8120,7 +6848,7 @@ async function readSafeDotenv2(dotenvPath, managedEnvironmentNames) {
   return content;
 }
 async function writeCredentialAtomically2(options) {
-  const temporaryPath = path26.join(
+  const temporaryPath = path23.join(
     options.projectRoot,
     `.siteos-search-credential.${process.pid}.${randomUUID5()}.tmp`
   );
@@ -8199,19 +6927,7 @@ var ENVIRONMENT_FLAG2 = "--environment";
 var CREDENTIAL_FLAG2 = "--credential";
 var INSTALL_FLAG2 = "--install";
 var NAME_FLAG2 = "--name";
-var SLUG_FLAG2 = "--slug";
-var SOURCE_FLAG = "--source";
-var REPLACE_FLAG2 = "--replace";
 var SEARCH_HELP = `Usage:
-  siteos search project list [--json]
-  siteos search project create --slug <slug> --name <name> [--json]
-  siteos search project use <slug> [--replace] [--json]
-  siteos search project status [--json]
-  siteos search environment list [--json]
-  siteos search environment create --slug <slug> --name <name> [--json]
-  siteos search environment update --environment <slug> --name <name> [--json]
-  siteos search environment fork --source <slug> --slug <slug> --name <name> [--json]
-  siteos search environment delete --environment <slug> [--json]
   siteos search analytics --environment <slug> [--json]
   siteos search diagnostics --environment <slug> [--json]
   siteos search doctor --environment <slug> [--json]
@@ -8233,13 +6949,27 @@ async function runSearchCommand(options) {
   if (options.args.some((arg) => splitFlag2(arg)[0] === "--env")) {
     return usageError4("Use --environment for SiteOS search environments.");
   }
-  if (options.args[0] !== "project") {
+  const environmentFlags = options.args.flatMap(
+    (arg) => arg.startsWith("--environment=") ? ["--environment", arg.slice(14)] : [arg]
+  );
+  const environmentIndex = environmentFlags.indexOf("--environment");
+  options = {
+    ...options,
+    selectedEnvironment: environmentIndex >= 0 ? environmentFlags[environmentIndex + 1] : void 0
+  };
+  if (["project", "environment"].includes(options.args[0] ?? ""))
+    return usageError4(
+      "Use `siteos project` to manage Projects and environments."
+    );
+  {
     try {
       options = {
         ...options,
         args: await commonEnvironmentArguments(options, "search", options.args)
       };
     } catch (error) {
+      if (error instanceof SiteOSAuthApiError)
+        return formatAuthError2(error).error;
       return {
         exitCode: 1,
         stderr: error instanceof Error ? error.message : "Environment could not be selected."
@@ -8247,12 +6977,6 @@ async function runSearchCommand(options) {
     }
   }
   const [subcommand, ...args2] = options.args;
-  if (subcommand === "project") {
-    return runProjectCommand3({ ...options, args: args2 });
-  }
-  if (subcommand === "environment") {
-    return runEnvironmentCommand2({ ...options, args: args2 });
-  }
   if (subcommand === "credential") {
     return runCredentialCommand2({ ...options, args: args2, credentialKind: "query" });
   }
@@ -8268,269 +6992,6 @@ async function runSearchCommand(options) {
   }
   return usageError4("Unknown SiteOS search command.");
 }
-async function runProjectCommand3(options) {
-  const action = options.args[0];
-  if (!action || !["create", "list", "status", "use"].includes(action)) {
-    return usageError4("Unknown SiteOS search project command.");
-  }
-  const parsed = parseProjectFlags2(action, options.args.slice(1));
-  if (!parsed.ok) return parsed.error;
-  if (!options.fetchImpl) {
-    return {
-      exitCode: 1,
-      stderr: "SiteOS API access is unavailable in this runtime."
-    };
-  }
-  try {
-    const apiBaseUrl = resolveSiteOSSearchBaseUrl(options.env);
-    const grant = await serviceGrantProvider2(options).acquire({
-      audience: "siteos-search",
-      scopes: ["search:workspace:write"]
-    });
-    requireGrant2(grant, "search:workspace:write");
-    const client = createSiteOSSearchApiClient({
-      apiBaseUrl,
-      fetchImpl: options.fetchImpl
-    });
-    if (action === "list") {
-      const projects2 = await client.listProjects({ token: grant.accessToken });
-      requireProjectOrganization2(projects2, grant.grant.organizationId);
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson2({ projects: projects2 }) : formatProjectListOutput2(projects2)
-      };
-    }
-    if (action === "create") {
-      const project2 = await client.createProject({
-        name: parsed.name,
-        slug: parsed.slug,
-        token: grant.accessToken
-      });
-      requireProjectOrganization2([project2], grant.grant.organizationId);
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson2({ project: project2 }) : [
-          "SiteOS Search Project created.",
-          `Project: ${project2.slug}`,
-          `Name: ${project2.name}`,
-          `Run \`siteos search project use ${project2.slug}\` to select it for this repository.`
-        ].join("\n")
-      };
-    }
-    const reference = await inspectSearchProjectReference(
-      options.cwd ?? process.cwd()
-    );
-    const store = projectBindingStore3(options);
-    const locator = {
-      apiOrigin: apiBaseUrl,
-      repositoryRoot: reference.rootDir,
-      service: "search"
-    };
-    if (action === "use") {
-      const projects2 = await client.listProjects({ token: grant.accessToken });
-      requireProjectOrganization2(projects2, grant.grant.organizationId);
-      const matches = projects2.filter(
-        (project3) => project3.slug === parsed.slug
-      );
-      if (matches.length !== 1) {
-        throw new SiteOSSearchApiError({
-          code: matches.length === 0 ? "PROJECT_NOT_FOUND" : "INVALID_RESPONSE",
-          message: matches.length === 0 ? "The Search Project was not found." : "SiteOS Search returned an invalid response.",
-          status: matches.length === 0 ? 404 : void 0
-        });
-      }
-      const project2 = matches[0];
-      if (reference.status === "loaded" && reference.reference.project.slug !== project2.slug && !parsed.replace) {
-        throw new SearchProjectReferenceError(
-          "SEARCH_PROJECT_REFERENCE_CONFLICT",
-          "A different Search Project is already selected. Use --replace to replace it."
-        );
-      }
-      const previousBinding = await store.read(locator);
-      await store.write({
-        ...locator,
-        organizationId: grant.grant.organizationId,
-        project: { id: project2.id, slug: project2.slug }
-      });
-      try {
-        await writeSearchProjectReference({
-          expectedChecksum: reference.status === "loaded" ? reference.checksum : null,
-          project: { name: project2.name, slug: project2.slug },
-          rootDir: reference.rootDir
-        });
-      } catch (error) {
-        if (previousBinding) await store.write(previousBinding);
-        else await store.remove(locator);
-        throw error;
-      }
-      const output2 = {
-        apiOrigin: apiBaseUrl,
-        organizationId: grant.grant.organizationId,
-        project: project2,
-        referencePath: path27.join(
-          reference.rootDir,
-          ".siteos",
-          "search",
-          "project.json"
-        )
-      };
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson2(output2) : [
-          "SiteOS Search Project selected.",
-          `Project: ${project2.slug}`,
-          `Reference: ${output2.referencePath}`
-        ].join("\n")
-      };
-    }
-    if (reference.status === "missing") {
-      throw new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_REQUIRED",
-        "Select a Search Project for this repository first."
-      );
-    }
-    const binding = await store.read(locator);
-    if (!binding || binding.organizationId !== grant.grant.organizationId || binding.project.slug !== reference.reference.project.slug) {
-      throw new SearchProjectReferenceError(
-        binding ? "SEARCH_PROJECT_REFERENCE_INVALID" : "SEARCH_PROJECT_REFERENCE_REQUIRED",
-        binding ? "The Search Project reference and private binding do not match." : "Select a Search Project for this repository first."
-      );
-    }
-    const projects = await client.listProjects({ token: grant.accessToken });
-    requireProjectOrganization2(projects, grant.grant.organizationId);
-    const project = projects.find(
-      (candidate) => candidate.id === binding.project.id
-    );
-    if (!project || project.slug !== binding.project.slug) {
-      throw new SiteOSSearchApiError({
-        code: "PROJECT_NOT_FOUND",
-        message: "The Search Project was not found.",
-        status: 404
-      });
-    }
-    const output = {
-      apiOrigin: apiBaseUrl,
-      connected: true,
-      organizationId: binding.organizationId,
-      project,
-      repositoryRoot: reference.rootDir
-    };
-    return {
-      exitCode: 0,
-      stdout: parsed.json ? stringifySafeJson2(output) : [
-        "SiteOS Search Project connection is valid.",
-        `Project: ${project.slug}`,
-        `Organization: ${binding.organizationId}`,
-        `API: ${apiBaseUrl}`
-      ].join("\n")
-    };
-  } catch (error) {
-    return formatProjectError2(error);
-  }
-}
-async function runEnvironmentCommand2(options) {
-  const [action, ...args2] = options.args;
-  if (!action || !["list", "create", "update", "fork", "delete"].includes(action)) {
-    return usageError4("Unknown SiteOS search environment command.");
-  }
-  const parsed = parseEnvironmentFlags2(action, args2);
-  if (!parsed.ok) return parsed.error;
-  return runWithSearchClient(options, async ({ client, context }) => {
-    const authorization = {
-      projectId: context.projectId,
-      token: context.credential
-    };
-    if (action === "list") {
-      const environments = await client.listEnvironments(authorization);
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson2({ environments }) : [
-          "SiteOS Search Environments.",
-          `Environments: ${environments.length}`,
-          ...environments.map(({ slug: slug2, name }) => `- ${slug2}: ${name}`)
-        ].join("\n")
-      };
-    }
-    const environment = action === "create" ? await client.createEnvironment({
-      ...authorization,
-      slug: parsed.slug,
-      name: parsed.name
-    }) : action === "update" ? await client.updateEnvironment({
-      ...authorization,
-      environmentSlug: parsed.environmentSlug,
-      name: parsed.name
-    }) : action === "fork" ? await client.forkEnvironment({
-      ...authorization,
-      sourceEnvironmentSlug: parsed.sourceSlug,
-      slug: parsed.slug,
-      name: parsed.name
-    }) : void 0;
-    if (action === "delete") {
-      const result = await client.deleteEnvironment({
-        ...authorization,
-        environmentSlug: parsed.environmentSlug
-      });
-      return {
-        exitCode: 0,
-        stdout: parsed.json ? stringifySafeJson2({ environment: parsed.environmentSlug, result }) : `SiteOS Search Environment ${parsed.environmentSlug} deleted.`
-      };
-    }
-    return {
-      exitCode: 0,
-      stdout: parsed.json ? stringifySafeJson2({ environment }) : `SiteOS Search Environment ${environment.slug} ${action === "fork" ? "forked" : action === "create" ? "created" : "updated"}.`
-    };
-  });
-}
-function parseEnvironmentFlags2(action, args2) {
-  const required = action === "create" ? [SLUG_FLAG2, NAME_FLAG2] : action === "update" ? [ENVIRONMENT_FLAG2, NAME_FLAG2] : action === "fork" ? [SOURCE_FLAG, SLUG_FLAG2, NAME_FLAG2] : action === "delete" ? [ENVIRONMENT_FLAG2] : [];
-  const allowed = /* @__PURE__ */ new Set([JSON_FLAG2, ...required]);
-  const flags = /* @__PURE__ */ new Map();
-  for (let index = 0; index < args2.length; index += 1) {
-    const [flag, inlineValue] = splitFlag2(args2[index]);
-    if (!allowed.has(flag) || flags.has(flag)) {
-      return { error: usageError4(`Unexpected argument: ${flag}`), ok: false };
-    }
-    if (flag === JSON_FLAG2) {
-      if (inlineValue !== void 0) {
-        return {
-          error: usageError4("--json does not accept a value."),
-          ok: false
-        };
-      }
-      flags.set(flag, true);
-      continue;
-    }
-    const value = inlineValue ?? args2[index + 1];
-    if (!value || value.startsWith("--")) {
-      return { error: usageError4(`${flag} requires a value.`), ok: false };
-    }
-    flags.set(flag, value.trim());
-    if (inlineValue === void 0) index += 1;
-  }
-  for (const flag of required) {
-    if (!flags.has(flag))
-      return { error: usageError4(`${flag} is required.`), ok: false };
-  }
-  const environmentSlug = readCredentialStringFlag(flags, ENVIRONMENT_FLAG2);
-  const sourceSlug = readCredentialStringFlag(flags, SOURCE_FLAG);
-  const slug2 = readCredentialStringFlag(flags, SLUG_FLAG2);
-  if ([environmentSlug, sourceSlug, slug2].some(
-    (value) => value && !isValidEnvironmentSlug(value)
-  )) {
-    return { error: usageError4("Environment slugs must be valid."), ok: false };
-  }
-  const name = readCredentialStringFlag(flags, NAME_FLAG2);
-  if (name && name.length > 255)
-    return { error: usageError4("--name is invalid."), ok: false };
-  return {
-    ...environmentSlug ? { environmentSlug } : {},
-    json: flags.has(JSON_FLAG2),
-    ...name ? { name } : {},
-    ok: true,
-    ...slug2 ? { slug: slug2 } : {},
-    ...sourceSlug ? { sourceSlug } : {}
-  };
-}
 async function runCredentialCommand2(options) {
   const action = options.args[0];
   if (!action || !["issue", "list", "revoke", "rotate"].includes(action)) {
@@ -8703,18 +7164,12 @@ async function completeCredentialInstallation(options) {
 async function loadCredentialManagementContext2(options) {
   try {
     const local = await readLocalCommonProject(options);
-    let rootDir = local?.rootDir;
-    if (!rootDir) {
-      const reference = await inspectSearchProjectReference(
-        options.cwd ?? process.cwd()
-      );
-      if (reference.status === "missing")
-        throw new SearchProjectReferenceError(
-          "SEARCH_PROJECT_REFERENCE_REQUIRED",
-          "Select a Search Project for this repository first."
-        );
-      rootDir = reference.rootDir;
-    }
+    if (!local)
+      throw new SiteOSAuthApiError({
+        code: "PROJECT_REQUIRED",
+        message: "Select a Project with `siteos project use <id-or-slug>`."
+      });
+    const rootDir = local.rootDir;
     const installation = options.install ? await (options.credentialKind === "query" ? options.prepareCredentialInstallation ?? prepareSiteOSSearchCredentialInstallation : options.prepareIndexingCredentialInstallation ?? prepareSiteOSSearchIndexingCredentialInstallation)({ projectRoot: rootDir }) : void 0;
     const context = await loadSearchContext(options, "search:credential:issue");
     if (!context.ok) return context;
@@ -8806,21 +7261,30 @@ async function loadSearchContext(options, requiredScope = "search:workspace:writ
     };
   }
   try {
-    const common = await commonServiceContext(options, "search");
-    if (common) {
-      const grant2 = await serviceGrantProvider2(options).acquire({
+    const common = await commonServiceContext(
+      options,
+      "search",
+      options.selectedEnvironment
+    );
+    if (!common)
+      throw new SiteOSAuthApiError({
+        code: "PROJECT_REQUIRED",
+        message: "Select a Project with `siteos project use <id-or-slug>`."
+      });
+    {
+      const grant = await serviceGrantProvider2(options).acquire({
         audience: "siteos-search",
         scopes: [requiredScope]
       });
-      requireGrant2(grant2, requiredScope);
-      if (grant2.grant.organizationId !== common.overview.project.organizationId)
+      requireGrant2(grant, requiredScope);
+      if (grant.grant.organizationId !== common.overview.project.organizationId)
         throw new SiteOSAuthApiError({
           code: "PROJECT_ORGANIZATION_MISMATCH",
           message: "The Project and service grant belong to different organizations."
         });
       return {
         apiBaseUrl: common.api.origin,
-        credential: grant2.accessToken,
+        credential: grant.accessToken,
         ok: true,
         project: {
           id: common.resourceId,
@@ -8831,53 +7295,9 @@ async function loadSearchContext(options, requiredScope = "search:workspace:writ
         rootDir: common.rootDir
       };
     }
-    const reference = await inspectSearchProjectReference(
-      options.cwd ?? process.cwd()
-    );
-    if (reference.status === "missing") {
-      throw new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_REQUIRED",
-        "Select a Search Project for this repository first."
-      );
-    }
-    const apiBaseUrl = resolveSiteOSSearchBaseUrl(options.env);
-    const binding = await projectBindingStore3(options).read({
-      apiOrigin: apiBaseUrl,
-      repositoryRoot: reference.rootDir,
-      service: "search"
-    });
-    if (!binding) {
-      throw new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_REQUIRED",
-        "Select a Search Project for this repository first."
-      );
-    }
-    const grant = await serviceGrantProvider2(options).acquire({
-      audience: "siteos-search",
-      scopes: [requiredScope]
-    });
-    requireGrant2(grant, requiredScope);
-    if (grant.grant.organizationId !== binding.organizationId || binding.project.slug !== reference.reference.project.slug) {
-      throw new SearchProjectReferenceError(
-        "SEARCH_PROJECT_REFERENCE_INVALID",
-        "The Search Project reference, private binding, and Auth Organization do not match."
-      );
-    }
-    return {
-      apiBaseUrl,
-      credential: grant.accessToken,
-      ok: true,
-      project: {
-        id: binding.project.id,
-        name: reference.reference.project.name,
-        slug: binding.project.slug
-      },
-      projectId: binding.project.id,
-      rootDir: reference.rootDir
-    };
   } catch (error) {
     if (error instanceof SiteOSAuthApiError) return formatAuthError2(error);
-    return { error: formatProjectError2(error), ok: false };
+    return { error: formatProjectError(error), ok: false };
   }
 }
 function formatAuthError2(error) {
@@ -8903,92 +7323,6 @@ function formatAuthError2(error) {
     ok: false
   };
 }
-function parseProjectFlags2(action, args2) {
-  const flags = /* @__PURE__ */ new Map();
-  const positionals = [];
-  const allowed = /* @__PURE__ */ new Set([
-    JSON_FLAG2,
-    ...action === "create" ? [NAME_FLAG2, SLUG_FLAG2] : [],
-    ...action === "use" ? [REPLACE_FLAG2] : []
-  ]);
-  const boolean = /* @__PURE__ */ new Set([JSON_FLAG2, REPLACE_FLAG2]);
-  for (let index = 0; index < args2.length; index += 1) {
-    const arg = args2[index];
-    if (!arg.startsWith("--")) {
-      positionals.push(arg);
-      continue;
-    }
-    const [flag, inlineValue] = splitFlag2(arg);
-    if (!allowed.has(flag) || flags.has(flag)) {
-      return { error: usageError4(`Unexpected argument: ${flag}`), ok: false };
-    }
-    if (boolean.has(flag)) {
-      if (inlineValue !== void 0) {
-        return {
-          error: usageError4(`${flag} does not accept a value.`),
-          ok: false
-        };
-      }
-      flags.set(flag, true);
-      continue;
-    }
-    const value = inlineValue ?? args2[index + 1];
-    if (!value || value.startsWith("--")) {
-      return { error: usageError4(`${flag} requires a value.`), ok: false };
-    }
-    flags.set(flag, value.trim());
-    if (inlineValue === void 0) index += 1;
-  }
-  if (action === "use") {
-    if (positionals.length !== 1 || !isValidProjectSlug(positionals[0])) {
-      return {
-        error: usageError4(
-          "Project use requires exactly one valid Project slug."
-        ),
-        ok: false
-      };
-    }
-    return {
-      json: flags.has(JSON_FLAG2),
-      ok: true,
-      replace: flags.has(REPLACE_FLAG2),
-      slug: positionals[0]
-    };
-  }
-  if (positionals.length > 0) {
-    return {
-      error: usageError4(`Unexpected argument: ${positionals[0]}`),
-      ok: false
-    };
-  }
-  if (action !== "create") {
-    return { json: flags.has(JSON_FLAG2), ok: true, replace: false };
-  }
-  const slug2 = readCredentialStringFlag(flags, SLUG_FLAG2);
-  const name = readCredentialStringFlag(flags, NAME_FLAG2);
-  if (!slug2 || !isValidProjectSlug(slug2)) {
-    return {
-      error: usageError4("--slug is required and must be valid."),
-      ok: false
-    };
-  }
-  if (!name || name.length > 255) {
-    return {
-      error: usageError4("--name is required and must be valid."),
-      ok: false
-    };
-  }
-  return {
-    json: flags.has(JSON_FLAG2),
-    name,
-    ok: true,
-    replace: false,
-    slug: slug2
-  };
-}
-function isValidProjectSlug(value) {
-  return value.length >= 1 && value.length <= 120 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-}
 function parseCredentialFlags2(action, args2, credentialKind) {
   const installs = action === "issue" || action === "rotate";
   const revokes = action === "revoke";
@@ -9120,7 +7454,7 @@ function formatCredentialError2(error) {
     stderr: "SiteOS Search credential request failed."
   };
 }
-function formatProjectError2(error) {
+function formatProjectError(error) {
   if (error instanceof SiteOSAuthApiError) return formatAuthError2(error).error;
   if (error instanceof SiteOSSearchApiError) {
     return {
@@ -9132,7 +7466,7 @@ function formatProjectError2(error) {
       ].filter((line) => Boolean(line)).join("\n")
     };
   }
-  if (error instanceof SearchProjectReferenceError || error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
+  if (error instanceof ProjectBindingStoreError || error instanceof RepositoryRootError) {
     return {
       exitCode: 1,
       stderr: [
@@ -9150,14 +7484,6 @@ function serviceGrantProvider2(options) {
     fetchImpl: options.fetchImpl
   });
 }
-function projectBindingStore3(options) {
-  return options.projectBindingStore ?? new NodeProjectBindingStore(
-    path27.join(
-      resolveSiteOSConfigHome({ env: options.env }),
-      "project-bindings.json"
-    )
-  );
-}
 function requireGrant2(grant, scope) {
   if (grant.grant.audience !== "siteos-search" || grant.grant.scopes.length !== 1 || grant.grant.scopes[0] !== scope) {
     throw new SiteOSAuthApiError({
@@ -9166,23 +7492,6 @@ function requireGrant2(grant, scope) {
     });
   }
 }
-function requireProjectOrganization2(projects, organizationId) {
-  if (projects.some((project) => project.organizationId !== organizationId)) {
-    throw new SiteOSSearchApiError({
-      code: "INVALID_RESPONSE",
-      message: "SiteOS Search returned an invalid response."
-    });
-  }
-}
-function formatProjectListOutput2(projects) {
-  return [
-    "SiteOS Search Projects.",
-    `Projects: ${projects.length}`,
-    ...projects.map(
-      (project) => `- ${project.slug}: ${project.name} (${project.id})`
-    )
-  ].join("\n");
-}
 function formatCredentialListOutput2(input) {
   return [
     `SiteOS Search ${credentialKindLabel(input.credentialKind)} credentials.`,
@@ -9254,7 +7563,7 @@ var PROJECT_HELP = `One Project for your website and all its services.
 Usage:
   siteos project list [--json]
   siteos project create --name <name> --slug <slug> [--url <url>] [--domain <domain>] [--json]
-  siteos project use <id-or-slug> [--json]
+  siteos project use <id-or-slug> [--environment <slug>] [--json]
   siteos project update [--name <name>] [--slug <slug>] [--url <production-url>] [--json]
   siteos project status [--json]
   siteos project connect <pulse|cookie|forms|search|trace|seo|analytics> [--resource <id>] [--json]
@@ -9268,13 +7577,13 @@ Usage:
 Select a Project once per repository. Service commands use its configured resources.
 Connect creates a draft workspace, or explicitly attaches an existing resource.
 It does not publish a banner, install a script, send a notification or deploy checks.`;
-async function runProjectCommand4(options) {
+async function runProjectCommand(options) {
   if (!options.args.length || options.args.some((arg) => arg === "--help" || arg === "-h"))
     return { exitCode: 0, stdout: PROJECT_HELP };
   try {
     const [action, ...args2] = options.args;
     if (action === "environment")
-      return await runEnvironmentCommand3({ ...options, args: args2 });
+      return await runEnvironmentCommand({ ...options, args: args2 });
     if (!["list", "create", "use", "status", "connect", "update"].includes(
       action
     ))
@@ -9285,6 +7594,7 @@ async function runProjectCommand4(options) {
       strict: true,
       options: {
         json: { type: "boolean" },
+        ...action === "use" ? { environment: { type: "string" } } : {},
         ...action === "create" || action === "update" ? {
           name: { type: "string" },
           slug: { type: "string" },
@@ -9324,15 +7634,23 @@ Select it with \`siteos project use ${project.slug}\`.`;
           matches.length ? "Use the exact Project ID to disambiguate this selection." : "Project not found in the active organization."
         );
       const project = matches[0];
+      const environment = project.environments.find(
+        (item) => item.slug === (parsed.values.environment ?? "production")
+      );
+      if (!environment)
+        throw new Error(
+          "Select an available Project environment with --environment <slug>."
+        );
       await store.write({
         apiOrigin: api.origin,
         repositoryRoot: await findRepositoryRoot(options.cwd ?? process.cwd()),
         service: "project",
         organizationId: project.organizationId,
-        project: { id: project.id, slug: project.slug }
+        project: { id: project.id, slug: project.slug },
+        environmentSlug: environment.slug
       });
-      result = { project };
-      message = `Selected ${project.name} for this repository.
+      result = { project, environment };
+      message = `Selected ${project.name} / ${environment.name} for this repository.
 Run \`siteos project status\` to inspect its services.`;
     } else {
       const context = await readCommonProject(options);
@@ -9388,7 +7706,7 @@ ${overview.services.map((service) => `${service.service}: ${service.observation?
 function projectLabel(project) {
   return `${project.name} (${project.slug})`;
 }
-async function runEnvironmentCommand3(options) {
+async function runEnvironmentCommand(options) {
   const [action, ...args2] = options.args;
   if (!["list", "create", "connect", "resources", "use", "update"].includes(
     action
@@ -9424,7 +7742,7 @@ async function runEnvironmentCommand3(options) {
     throw new Error("Choose a Project environment with --environment <slug>.");
   const context = await readCommonProject(
     options,
-    action === "use" ? "production" : void 0
+    action === "use" ? positionals[0] : void 0
   );
   if (!context)
     throw new Error("Select a Project with `siteos project use` first.");
@@ -9501,13 +7819,13 @@ async function runEnvironmentCommand3(options) {
 }
 
 // src/services/service-command.ts
-import { readFile as readFile16, stat } from "fs/promises";
-import path28 from "path";
+import { readFile as readFile15, stat } from "fs/promises";
+import path24 from "path";
 import { parseArgs as parseArgs3 } from "util";
-import { z as z16 } from "zod";
+import { z as z13 } from "zod";
 
 // src/services/trace-explorer-command.ts
-import { z as z14 } from "zod";
+import { z as z11 } from "zod";
 var filters = [
   "environment",
   "provider",
@@ -9530,8 +7848,8 @@ var TRACE_EXPLORER_FLAGS = {
   "issue show": ["environment", "id", "cursor"],
   "observation show": ["environment", "batch-id", "event-id"]
 };
-var FilterValues = z14.object({
-  provider: z14.enum([
+var FilterValues = z11.object({
+  provider: z11.enum([
     "siteos_analytics",
     "ga4",
     "google_ads",
@@ -9539,11 +7857,11 @@ var FilterValues = z14.object({
     "meta",
     "custom"
   ]).optional(),
-  event: z14.string().min(1).max(160).optional(),
-  property: z14.string().min(1).max(160).optional(),
-  "page-view": z14.string().uuid().optional(),
-  search: z14.string().max(160).optional(),
-  state: z14.enum([
+  event: z11.string().min(1).max(160).optional(),
+  property: z11.string().min(1).max(160).optional(),
+  "page-view": z11.string().uuid().optional(),
+  search: z11.string().max(160).optional(),
+  state: z11.enum([
     "all",
     "active",
     "snoozed",
@@ -9553,8 +7871,8 @@ var FilterValues = z14.object({
     "tracked",
     "ignored"
   ]).optional(),
-  rule: z14.string().min(1).max(80).optional(),
-  kind: z14.enum([
+  rule: z11.string().min(1).max(80).optional(),
+  kind: z11.enum([
     "data_layer",
     "fetch",
     "xhr",
@@ -9564,8 +7882,8 @@ var FilterValues = z14.object({
     "heartbeat",
     "runtime_diagnostic"
   ]).optional(),
-  period: z14.enum(["24h", "7d"]).optional(),
-  cursor: z14.string().min(1).max(4096).optional()
+  period: z11.enum(["24h", "7d"]).optional(),
+  cursor: z11.string().min(1).max(4096).optional()
 });
 function traceExplorerSuffix(route, values) {
   if (!TRACE_EXPLORER_FLAGS[route]) return null;
@@ -9573,11 +7891,11 @@ function traceExplorerSuffix(route, values) {
   if (route === "issue show" || route === "observation show") {
     const keys = route === "issue show" ? ["id"] : ["batch-id", "event-id"];
     for (const key of keys) {
-      if (!z14.string().uuid().safeParse(values[key]).success)
+      if (!z11.string().uuid().safeParse(values[key]).success)
         throw new Error(`Use --${key} with the UUID returned by Trace.`);
     }
     if (values.cursor !== void 0) {
-      if (!z14.string().uuid().safeParse(values.cursor).success)
+      if (!z11.string().uuid().safeParse(values.cursor).success)
         throw new Error(
           "Use --cursor with the nextCursor returned by this issue."
         );
@@ -9814,8 +8132,8 @@ async function runServiceCommand(service, options) {
       );
       const result2 = await response.json();
       if (!response.ok) {
-        const error = z16.object({
-          error: z16.object({ code: z16.string(), message: z16.string().max(500) })
+        const error = z13.object({
+          error: z13.object({ code: z13.string(), message: z13.string().max(500) })
         }).safeParse(result2);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SERVICE_REQUEST_FAILED",
@@ -9828,11 +8146,11 @@ async function runServiceCommand(service, options) {
     async function inputFile() {
       if (!values.input)
         throw new Error("This operation requires --input <json-file>.");
-      const filename = path28.resolve(options.cwd ?? process.cwd(), values.input);
+      const filename = path24.resolve(options.cwd ?? process.cwd(), values.input);
       const info = await stat(filename);
       if (!info.isFile() || info.size > 512 * 1024)
         throw new Error("Use a JSON file smaller than 512 KB.");
-      return JSON.parse(await readFile16(filename, "utf8"));
+      return JSON.parse(await readFile15(filename, "utf8"));
     }
     const site = common ? `/sites/${encodeURIComponent(common.resourceId)}` : "";
     let result;
@@ -9852,9 +8170,9 @@ async function runServiceCommand(service, options) {
           await inputFile(),
           "cookie:workspace:read"
         );
-        const validation = z16.object({
-          valid: z16.boolean(),
-          draftVersionMatches: z16.boolean().optional()
+        const validation = z13.object({
+          valid: z13.boolean(),
+          draftVersionMatches: z13.boolean().optional()
         }).parse(result);
         if (!validation.valid || validation.draftVersionMatches === false)
           return { exitCode: 2, stdout: JSON.stringify(result, null, 2) };
@@ -9893,11 +8211,11 @@ async function runServiceCommand(service, options) {
       } else if (action === "installation")
         result = await request(`${site}/installation`);
       else if (action === "draft" && subaction === "get" && positionals.length === 2) {
-        const response = z16.object({
-          name: z16.string(),
-          hostname: z16.string(),
-          draftVersion: z16.number(),
-          draft: z16.unknown()
+        const response = z13.object({
+          name: z13.string(),
+          hostname: z13.string(),
+          draftVersion: z13.number(),
+          draft: z13.unknown()
         }).parse(await request(site));
         result = {
           name: response.name,
@@ -9929,9 +8247,9 @@ async function runServiceCommand(service, options) {
       else if (action === "environments" && positionals.length === 1)
         result = await request(`${site}/environments`);
       else if (action === "report" || action === "installation" || action === "tracking-plan" || explorerSuffix !== null) {
-        const response = z16.object({
-          environments: z16.array(
-            z16.object({ id: z16.string(), slug: z16.string() })
+        const response = z13.object({
+          environments: z13.array(
+            z13.object({ id: z13.string(), slug: z13.string() })
           )
         }).parse(await request(`${site}/environments`));
         const environment = common.overview.project.environments.find(
@@ -9958,11 +8276,11 @@ async function runServiceCommand(service, options) {
         if (explorerSuffix !== null) {
           result = await request(`${base}${explorerSuffix}`);
         } else if (action === "report" && positionals.length === 1) {
-          const detail = z16.object({
-            site: z16.object({
-              id: z16.literal(common.resourceId),
-              environments: z16.array(
-                z16.object({ id: z16.string(), evidence: z16.unknown() })
+          const detail = z13.object({
+            site: z13.object({
+              id: z13.literal(common.resourceId),
+              environments: z13.array(
+                z13.object({ id: z13.string(), evidence: z13.unknown() })
               )
             })
           }).parse(await request(site));
@@ -10020,16 +8338,16 @@ async function runServiceCommand(service, options) {
   } catch (cause) {
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
-      stderr: cause instanceof SiteOSAuthApiError || !(cause instanceof z16.ZodError) && cause instanceof Error ? cause.message : "The service returned an invalid response."
+      stderr: cause instanceof SiteOSAuthApiError || !(cause instanceof z13.ZodError) && cause instanceof Error ? cause.message : "The service returned an invalid response."
     };
   }
 }
 
 // src/services/analytics-command.ts
-import { readFile as readFile17, stat as stat2 } from "fs/promises";
-import path29 from "path";
+import { readFile as readFile16, stat as stat2 } from "fs/promises";
+import path25 from "path";
 import { parseArgs as parseArgs4 } from "util";
-import { z as z17 } from "zod";
+import { z as z14 } from "zod";
 var ANALYTICS_HELP = `Set up website Analytics in the selected Project environment.
 
 Usage:
@@ -10060,27 +8378,27 @@ Settings require an owner/admin, the current revision and at least one change.
 Catalog files are bounded JSON using the documented event/campaign/goal/funnel contracts.
 Monitoring preparation creates a Trace draft only; publication remains a separate operation.
 Analytics is Unlimited during early access. No synthetic events are sent by these commands.`;
-var EventInput = z17.object({
-  name: z17.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
-  label: z17.string().trim().min(1).max(80),
-  properties: z17.record(
-    z17.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
-    z17.array(
-      z17.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
+var EventInput = z14.object({
+  name: z14.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
+  label: z14.string().trim().min(1).max(80),
+  properties: z14.record(
+    z14.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
+    z14.array(
+      z14.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
     ).min(1).max(20)
   ).refine((v) => Object.keys(v).length <= 8)
 }).strict();
-var Resource = z17.object({
-  id: z17.string(),
-  organizationId: z17.string(),
-  name: z17.string(),
-  slug: z17.string(),
-  origin: z17.string().url(),
-  publicKey: z17.string(),
-  revision: z17.number().int().positive(),
-  enabled: z17.boolean(),
-  cookieEvents: z17.boolean(),
-  minimalRealtime: z17.boolean()
+var Resource = z14.object({
+  id: z14.string(),
+  organizationId: z14.string(),
+  name: z14.string(),
+  slug: z14.string(),
+  origin: z14.string().url(),
+  publicKey: z14.string(),
+  revision: z14.number().int().positive(),
+  enabled: z14.boolean(),
+  cookieEvents: z14.boolean(),
+  minimalRealtime: z14.boolean()
 });
 var readKeys = [
   "days",
@@ -10210,7 +8528,7 @@ async function runAnalyticsCommand(options) {
       throw new Error("Use --days 1, 7 or 28.");
     if (values.country && !/^(?:[A-Z]{2}|unknown)$/u.test(values.country))
       throw new Error("Use an uppercase ISO country code or unknown.");
-    if (values.campaign) z17.string().uuid().parse(values.campaign);
+    if (values.campaign) z14.string().uuid().parse(values.campaign);
     const setting = route === "settings set", creating = positionals[1] === "create", archive = positionals[1] === "archive";
     let body;
     if (setting) {
@@ -10234,10 +8552,10 @@ async function runAnalyticsCommand(options) {
     } else if (creating) {
       if (!values.file)
         throw new Error("Creation requires --file with a JSON definition.");
-      const filename = path29.resolve(options.cwd ?? process.cwd(), values.file);
+      const filename = path25.resolve(options.cwd ?? process.cwd(), values.file);
       if ((await stat2(filename)).size > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
-      const text = await readFile17(filename, "utf8");
+      const text = await readFile16(filename, "utf8");
       if (Buffer.byteLength(text) > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
       let definition;
@@ -10246,9 +8564,9 @@ async function runAnalyticsCommand(options) {
       } catch {
         throw new Error("The definition must contain valid JSON.");
       }
-      body = z17.record(z17.unknown()).parse(definition);
+      body = z14.record(z14.unknown()).parse(definition);
       if (action === "events") body = EventInput.parse(body);
-    } else if (archive) body = { id: z17.string().uuid().parse(positionals[2]) };
+    } else if (archive) body = { id: z14.string().uuid().parse(positionals[2]) };
     const context = await commonServiceContext(
       options,
       "analytics",
@@ -10295,8 +8613,8 @@ async function runAnalyticsCommand(options) {
     );
     const value = await response.json();
     if (!response.ok) {
-      const error = z17.object({
-        error: z17.object({ code: z17.string(), message: z17.string().max(500) })
+      const error = z14.object({
+        error: z14.object({ code: z14.string(), message: z14.string().max(500) })
       }).safeParse(value);
       throw new SiteOSAuthApiError({
         code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
@@ -10304,9 +8622,9 @@ async function runAnalyticsCommand(options) {
         status: response.status
       });
     }
-    const record = z17.object({
-      contractVersion: z17.literal(1),
-      resourceId: z17.literal(context.resourceId)
+    const record = z14.object({
+      contractVersion: z14.literal(1),
+      resourceId: z14.literal(context.resourceId)
     }).passthrough().parse(value);
     let output;
     if (setting) {
@@ -10325,16 +8643,16 @@ async function runAnalyticsCommand(options) {
           throw new Error("The saved event does not match this definition.");
       } else
         output = {
-          id: z17.string().uuid().parse(record.id),
+          id: z14.string().uuid().parse(record.id),
           ...pick(
             record,
             action === "campaigns" ? ["label", "source", "medium", "campaign"] : action === "goals" ? ["label", "match"] : ["label", "steps"]
           )
         };
     } else if (archive)
-      output = { archived: z17.literal(true).parse(record.archived) };
+      output = { archived: z14.literal(true).parse(record.archived) };
     else if (route === "monitoring prepare")
-      output = { state: z17.literal("prepared").parse(record.state) };
+      output = { state: z14.literal("prepared").parse(record.state) };
     else if (action === "realtime") output = pick(record, liveKeys);
     else {
       const resource = Resource.parse(record.resource);
@@ -10346,8 +8664,8 @@ async function runAnalyticsCommand(options) {
         output = {
           resource,
           lastReceivedAt: record.lastReceivedAt,
-          consentSource: z17.object({
-            consentSource: z17.enum([
+          consentSource: z14.object({
+            consentSource: z14.enum([
               "cookie",
               "external",
               "waiting_for_cookie",
@@ -10359,11 +8677,11 @@ async function runAnalyticsCommand(options) {
       else if (action === "installation")
         output = {
           resource,
-          installation: z17.string().parse(record.installation),
+          installation: z14.string().parse(record.installation),
           configuration: record.configuration
         };
       else if (action === "events") {
-        const definitions = z17.array(EventInput).parse(record.definitions);
+        const definitions = z14.array(EventInput).parse(record.definitions);
         if (route === "events snippet") {
           const definition = definitions.find((d) => d.name === positionals[2]);
           if (!definition)
@@ -10377,13 +8695,13 @@ async function runAnalyticsCommand(options) {
           };
         } else output = { definitions, eventCounts: record.eventCounts };
       } else
-        output = action === "report" ? pick(record, readKeys) : { [action]: z17.array(z17.unknown()).parse(record[action]) };
+        output = action === "report" ? pick(record, readKeys) : { [action]: z14.array(z14.unknown()).parse(record[action]) };
     }
     return { exitCode: 0, stdout: JSON.stringify(output, null, 2) };
   } catch (cause) {
     const error = cause instanceof SiteOSAuthApiError ? { code: cause.code, message: cause.message } : {
       code: "ANALYTICS_COMMAND_FAILED",
-      message: cause instanceof z17.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
+      message: cause instanceof z14.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -10394,20 +8712,20 @@ async function runAnalyticsCommand(options) {
 
 // src/services/seo-command.ts
 import { writeFile as writeFile10 } from "fs/promises";
-import path32 from "path";
+import path28 from "path";
 import { parseArgs as parseArgs8 } from "util";
-import { z as z22 } from "zod";
+import { z as z19 } from "zod";
 
 // src/services/seo-research-command.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { setTimeout as setTimeout2 } from "timers/promises";
 import { isDeepStrictEqual, parseArgs as parseArgs5 } from "util";
-import { z as z19 } from "zod";
+import { z as z16 } from "zod";
 
 // src/services/seo-report-client.ts
 import { open, writeFile as writeFile8 } from "fs/promises";
-import path30 from "path";
-import { z as z18 } from "zod";
+import path26 from "path";
+import { z as z15 } from "zod";
 async function seoReportClient(options, environment) {
   const context = await commonServiceContext(options, "seo", environment);
   if (!context)
@@ -10442,8 +8760,8 @@ async function seoReportClient(options, environment) {
         }
       );
       if (!response.ok) {
-        const result = z18.object({
-          error: z18.object({ code: z18.string(), message: z18.string().max(500) })
+        const result = z15.object({
+          error: z15.object({ code: z15.string(), message: z15.string().max(500) })
         }).safeParse(await response.json());
         throw new SiteOSAuthApiError({
           code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -10457,9 +8775,9 @@ async function seoReportClient(options, environment) {
     }
   };
 }
-var versionedReport = z18.object({ contractVersion: z18.literal(1) }).passthrough();
+var versionedReport = z15.object({ contractVersion: z15.literal(1) }).passthrough();
 async function readSeoInput(cwd, filename) {
-  const file = await open(path30.resolve(cwd ?? process.cwd(), filename), "r");
+  const file = await open(path26.resolve(cwd ?? process.cwd(), filename), "r");
   try {
     const stat3 = await file.stat();
     if (!stat3.isFile() || stat3.size > 32e3)
@@ -10483,14 +8801,14 @@ async function readSeoInput(cwd, filename) {
   }
 }
 async function writeSeoReport(options, filename, content) {
-  const output = path30.resolve(options.cwd ?? process.cwd(), filename);
+  const output = path26.resolve(options.cwd ?? process.cwd(), filename);
   await writeFile8(output, content, { flag: "wx", mode: 384 });
   return output;
 }
 function seoReportFailure(cause, json, idempotencyKey) {
   const error = {
     code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-    message: cause instanceof z18.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+    message: cause instanceof z15.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
   };
   return {
     exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -10546,11 +8864,11 @@ var kinds = [
   "brand",
   "ai-visibility"
 ];
-var requestSchema = z19.object({
-  kind: z19.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
-  target: z19.string().min(1).max(253)
+var requestSchema = z16.object({
+  kind: z16.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
+  target: z16.string().min(1).max(253)
 }).passthrough();
-var runStates = z19.enum([
+var runStates = z16.enum([
   "queued",
   "running",
   "completed",
@@ -10647,26 +8965,26 @@ async function runSeoResearchCommand(options) {
         );
     }
     const client = await seoReportClient(options, values.environment);
-    const resourceSchema = z19.object({
-      id: z19.literal(client.resourceId),
-      organizationId: z19.literal(client.organizationId)
+    const resourceSchema = z16.object({
+      id: z16.literal(client.resourceId),
+      organizationId: z16.literal(client.organizationId)
     }).passthrough();
-    const runSchema = z19.object({
-      id: z19.string(),
-      resourceId: z19.literal(client.resourceId),
-      organizationId: z19.literal(client.organizationId),
-      websiteUrl: z19.string(),
+    const runSchema = z16.object({
+      id: z16.string(),
+      resourceId: z16.literal(client.resourceId),
+      organizationId: z16.literal(client.organizationId),
+      websiteUrl: z16.string(),
       request: requestSchema,
       state: runStates,
-      createdAt: z19.string(),
-      finishedAt: z19.string().nullable(),
-      parts: z19.array(
-        z19.object({
-          key: z19.string(),
-          state: z19.enum(["completed", "failed"]),
-          error: z19.string().nullable(),
-          dataset: z19.record(z19.unknown()).nullable(),
-          observedAt: z19.string()
+      createdAt: z16.string(),
+      finishedAt: z16.string().nullable(),
+      parts: z16.array(
+        z16.object({
+          key: z16.string(),
+          state: z16.enum(["completed", "failed"]),
+          error: z16.string().nullable(),
+          dataset: z16.record(z16.unknown()).nullable(),
+          observedAt: z16.string()
         }).passthrough()
       )
     }).passthrough();
@@ -10680,36 +8998,36 @@ async function runSeoResearchCommand(options) {
     const query = `?kind=${encodeURIComponent(values.kind ?? "rankings")}`;
     let record;
     if (action.startsWith("serp ")) {
-      const snapshotSchema = z19.object({
-        id: z19.string(),
-        organizationId: z19.literal(client.organizationId),
-        resourceId: z19.literal(client.resourceId),
-        sourceRunId: z19.literal(id),
+      const snapshotSchema = z16.object({
+        id: z16.string(),
+        organizationId: z16.literal(client.organizationId),
+        resourceId: z16.literal(client.resourceId),
+        sourceRunId: z16.literal(id),
         request: requestSchema,
-        keywordKey: z19.literal(
+        keywordKey: z16.literal(
           values.keyword.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ")
         ),
-        state: z19.enum([
+        state: z16.enum([
           "queued",
           "running",
           "completed",
           "failed",
           "cancelled"
         ]),
-        dataset: z19.object({
-          type: z19.literal("serp"),
-          keyword: z19.string(),
-          country: z19.string(),
-          language: z19.string(),
-          device: z19.enum(["desktop", "mobile"]),
-          observedAt: z19.string(),
-          rows: z19.array(
-            z19.object({
-              position: z19.number(),
-              title: z19.string(),
-              url: z19.string(),
-              domain: z19.string(),
-              description: z19.string()
+        dataset: z16.object({
+          type: z16.literal("serp"),
+          keyword: z16.string(),
+          country: z16.string(),
+          language: z16.string(),
+          device: z16.enum(["desktop", "mobile"]),
+          observedAt: z16.string(),
+          rows: z16.array(
+            z16.object({
+              position: z16.number(),
+              title: z16.string(),
+              url: z16.string(),
+              domain: z16.string(),
+              description: z16.string()
             })
           )
         }).nullable()
@@ -10802,9 +9120,9 @@ async function runSeoResearchCommand(options) {
           name: values.name.trim(),
           ...values.id ? { id: values.id } : {}
         });
-        const saved = z19.object({
-          id: z19.string(),
-          name: z19.literal(values.name.trim()),
+        const saved = z16.object({
+          id: z16.string(),
+          name: z16.literal(values.name.trim()),
           request: requestSchema
         }).parse(record.saved);
         if (values.id && saved.id !== values.id || !isDeepStrictEqual(saved.request, plan.request))
@@ -10818,23 +9136,23 @@ async function runSeoResearchCommand(options) {
         action === "cancel" ? "run" : "write",
         {}
       );
-      z19.literal(true).parse(
+      z16.literal(true).parse(
         record[action === "cancel" ? "cancelled" : "removed"]
       );
     } else if (action === "summary") {
       record = await get("/summary");
       resourceSchema.parse(record.resource);
-      z19.array(z19.object({ kind: z19.enum(kinds), summary: z19.unknown() })).parse(
+      z16.array(z16.object({ kind: z16.enum(kinds), summary: z16.unknown() })).parse(
         record.checks
       );
     } else if (["status", "history", "saved list"].includes(action)) {
       const view = await get(query);
       resourceSchema.parse(view.resource);
-      const runs = z19.array(runSchema).parse(view.runs);
-      const saved = z19.array(
-        z19.object({
-          id: z19.string(),
-          name: z19.string(),
+      const runs = z16.array(runSchema).parse(view.runs);
+      const saved = z16.array(
+        z16.object({
+          id: z16.string(),
+          name: z16.string(),
           request: requestSchema
         }).passthrough()
       ).parse(view.saved);
@@ -10951,7 +9269,7 @@ async function runSeoResearchCommand(options) {
 
 // src/services/seo-gsc-command.ts
 import { parseArgs as parseArgs6 } from "util";
-import { z as z20 } from "zod";
+import { z as z17 } from "zod";
 var GSC_HELP = `
   siteos seo gsc status [--environment <slug>] [--json]
   siteos seo gsc report [--dataset <pages|queries>] [--query <text>] [--filter <all|issues|declining>] [--sort <clicks|change|impressions>] [--page <number>] [--url <page-url>] [--environment <slug>] [--json]
@@ -11051,13 +9369,13 @@ async function runSeoGscCommand(options) {
       `seo:search:${action === "sync" ? "sync" : writing ? "write" : "read"}`,
       body
     );
-    const runSchema = z20.object({
-      id: z20.string(),
-      resourceId: z20.literal(client.resourceId),
-      organizationId: z20.literal(client.organizationId),
-      websiteUrl: z20.string(),
-      siteUrl: z20.string(),
-      state: z20.enum([
+    const runSchema = z17.object({
+      id: z17.string(),
+      resourceId: z17.literal(client.resourceId),
+      organizationId: z17.literal(client.organizationId),
+      websiteUrl: z17.string(),
+      siteUrl: z17.string(),
+      state: z17.enum([
         "queued",
         "running",
         "completed",
@@ -11065,32 +9383,32 @@ async function runSeoGscCommand(options) {
         "failed",
         "cancelled"
       ]),
-      dates: z20.unknown()
+      dates: z17.unknown()
     }).passthrough();
-    const bindingSchema = z20.object({
-      resourceId: z20.literal(client.resourceId),
-      organizationId: z20.literal(client.organizationId),
-      websiteUrl: z20.string(),
-      siteUrl: z20.string(),
-      revision: z20.number().int().positive()
+    const bindingSchema = z17.object({
+      resourceId: z17.literal(client.resourceId),
+      organizationId: z17.literal(client.organizationId),
+      websiteUrl: z17.string(),
+      siteUrl: z17.string(),
+      revision: z17.number().int().positive()
     }).passthrough();
-    const metrics = z20.object({
-      clicks: z20.number(),
-      impressions: z20.number(),
-      ctr: z20.number(),
-      position: z20.number()
+    const metrics = z17.object({
+      clicks: z17.number(),
+      impressions: z17.number(),
+      ctr: z17.number(),
+      position: z17.number()
     }).passthrough().nullable();
     const validateView = (data) => {
       const record2 = versionedReport.parse(data);
-      z20.literal(client.resourceId).parse(record2.resourceId);
+      z17.literal(client.resourceId).parse(record2.resourceId);
       bindingSchema.nullable().parse(record2.binding);
       runSchema.nullable().parse(record2.latest);
       runSchema.nullable().parse(record2.report);
-      z20.array(
-        z20.object({ key: z20.string(), current: metrics, previous: metrics }).passthrough()
+      z17.array(
+        z17.object({ key: z17.string(), current: metrics, previous: metrics }).passthrough()
       ).parse(record2.rows);
-      z20.number().int().nonnegative().parse(record2.total);
-      z20.literal(values.dataset ?? "pages").parse(record2.dataset);
+      z17.number().int().nonnegative().parse(record2.total);
+      z17.literal(values.dataset ?? "pages").parse(record2.dataset);
       return record2;
     };
     if (action === "export") {
@@ -11106,9 +9424,9 @@ async function runSeoGscCommand(options) {
       const text = await response.text();
       if (values.format === "json") {
         const report = validateView(JSON.parse(text));
-        z20.literal(reportId).parse(runSchema.parse(report.report).id);
-        z20.array(z20.unknown()).length(rows).parse(report.rows);
-        z20.literal(truncated === "true").parse(report.truncated);
+        z17.literal(reportId).parse(runSchema.parse(report.report).id);
+        z17.array(z17.unknown()).length(rows).parse(report.rows);
+        z17.literal(truncated === "true").parse(report.truncated);
       }
       const output = await writeSeoReport(options, values.output, text);
       return {
@@ -11129,7 +9447,7 @@ async function runSeoGscCommand(options) {
       };
     }
     const record = versionedReport.parse(await response.json());
-    if (action === "disconnect") z20.literal(true).parse(record.unbound);
+    if (action === "disconnect") z17.literal(true).parse(record.unbound);
     else if (writing) {
       runSchema.parse(record.run);
       if (action === "bind") {
@@ -11149,10 +9467,10 @@ async function runSeoGscCommand(options) {
 // src/services/seo-performance-command.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { writeFile as writeFile9 } from "fs/promises";
-import path31 from "path";
+import path27 from "path";
 import { setTimeout as setTimeout3 } from "timers/promises";
 import { parseArgs as parseArgs7 } from "util";
-import { z as z21 } from "zod";
+import { z as z18 } from "zod";
 var PERFORMANCE_HELP = `
   siteos seo performance run --audit <id> --url <url> [--url <url>...] [--device <mobile|desktop>] [--idempotency-key <key>] [--environment <slug>] [--json]
   siteos seo performance list [--device <mobile|desktop>] [--environment <slug>] [--json]
@@ -11240,12 +9558,12 @@ async function runSeoPerformanceCommand(options) {
     const runtime = commonProjectRuntime(options);
     const writing = ["run", "cancel"].includes(action);
     const scope = writing ? "seo:audits:write" : "seo:workspace:read";
-    const batchSchema = z21.object({
-      id: z21.string(),
-      resourceId: z21.literal(context.resourceId),
-      organizationId: z21.literal(context.overview.project.organizationId),
-      sourceAuditId: z21.string(),
-      state: z21.enum([
+    const batchSchema = z18.object({
+      id: z18.string(),
+      resourceId: z18.literal(context.resourceId),
+      organizationId: z18.literal(context.overview.project.organizationId),
+      sourceAuditId: z18.string(),
+      state: z18.enum([
         "queued",
         "running",
         "completed",
@@ -11253,8 +9571,8 @@ async function runSeoPerformanceCommand(options) {
         "failed",
         "cancelled"
       ]),
-      device: z21.enum(["mobile", "desktop"]),
-      urls: z21.array(z21.string()).min(1).max(10)
+      device: z18.enum(["mobile", "desktop"]),
+      urls: z18.array(z18.string()).min(1).max(10)
     }).passthrough();
     const query = new URLSearchParams();
     if (values.device) query.set("device", values.device);
@@ -11302,17 +9620,17 @@ async function runSeoPerformanceCommand(options) {
           );
         const text = await response.text();
         if (values.format === "json") {
-          const parsed = z21.object({
-            contractVersion: z21.literal(1),
+          const parsed = z18.object({
+            contractVersion: z18.literal(1),
             batch: batchSchema,
-            pages: z21.array(z21.unknown())
+            pages: z18.array(z18.unknown())
           }).parse(JSON.parse(text));
           if (parsed.batch.id !== id)
             throw new Error(
               "The export response does not match the selected check."
             );
         }
-        const output = path31.resolve(
+        const output = path27.resolve(
           options.cwd ?? process.cwd(),
           values.output
         );
@@ -11328,8 +9646,8 @@ async function runSeoPerformanceCommand(options) {
       }
       const data = await response.json();
       if (!response.ok) {
-        const error = z21.object({
-          error: z21.object({ code: z21.string(), message: z21.string().max(500) })
+        const error = z18.object({
+          error: z18.object({ code: z18.string(), message: z18.string().max(500) })
         }).safeParse(data);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SEO_REQUEST_FAILED",
@@ -11337,8 +9655,8 @@ async function runSeoPerformanceCommand(options) {
           status: response.status
         });
       }
-      const record = z21.object({ contractVersion: z21.literal(1) }).passthrough().parse(data);
-      if (action === "cancel") z21.literal(true).parse(record.cancelled);
+      const record = z18.object({ contractVersion: z18.literal(1) }).passthrough().parse(data);
+      if (action === "cancel") z18.literal(true).parse(record.cancelled);
       else if (action === "run") {
         const accepted = batchSchema.parse(record.batch);
         const normalize = (url) => {
@@ -11351,8 +9669,8 @@ async function runSeoPerformanceCommand(options) {
             "The queued check does not match the requested source, device and URLs."
           );
       } else {
-        z21.literal(context.resourceId).parse(record.resourceId);
-        z21.array(batchSchema).parse(record.batches);
+        z18.literal(context.resourceId).parse(record.resourceId);
+        z18.array(batchSchema).parse(record.batches);
         const selected = batchSchema.nullable().parse(record.batch);
         if (id && selected?.id !== id)
           throw new Error(
@@ -11379,7 +9697,7 @@ async function runSeoPerformanceCommand(options) {
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z21.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
+      message: cause instanceof z18.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -11659,17 +9977,17 @@ async function runSeoCommand(options) {
         );
       const text = await response.text();
       if (values.format === "json")
-        z22.object({
-          contractVersion: z22.literal(1),
-          audit: z22.object({
-            id: z22.literal(values.audit),
-            resourceId: z22.literal(context.resourceId)
+        z19.object({
+          contractVersion: z19.literal(1),
+          audit: z19.object({
+            id: z19.literal(values.audit),
+            resourceId: z19.literal(context.resourceId)
           }),
-          kind: z22.literal(values.kind),
-          totalRows: z22.literal(rows),
-          rows: z22.array(z22.unknown()).length(rows)
+          kind: z19.literal(values.kind),
+          totalRows: z19.literal(rows),
+          rows: z19.array(z19.unknown()).length(rows)
         }).parse(JSON.parse(text));
-      const output = path32.resolve(options.cwd ?? process.cwd(), values.output);
+      const output = path28.resolve(options.cwd ?? process.cwd(), values.output);
       await writeFile10(output, text, { flag: "wx", mode: 384 });
       return {
         exitCode: 0,
@@ -11688,8 +10006,8 @@ async function runSeoCommand(options) {
     }
     const data = await response.json();
     if (!response.ok) {
-      const result = z22.object({
-        error: z22.object({ code: z22.string(), message: z22.string().max(500) })
+      const result = z19.object({
+        error: z19.object({ code: z19.string(), message: z19.string().max(500) })
       }).safeParse(data);
       throw new SiteOSAuthApiError({
         code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -11697,34 +10015,34 @@ async function runSeoCommand(options) {
         status: response.status
       });
     }
-    const record = z22.object({ contractVersion: z22.literal(1) }).passthrough().parse(data);
+    const record = z19.object({ contractVersion: z19.literal(1) }).passthrough().parse(data);
     if (automation) {
-      z22.literal(context.resourceId).parse(record.resourceId);
-      const schedule = z22.object({
-        enabled: z22.boolean(),
-        weekday: z22.number().int().min(1).max(7),
-        time: z22.string(),
-        timeZone: z22.string(),
-        revision: z22.number().int().min(0),
-        nextRunAt: z22.string().nullable()
+      z19.literal(context.resourceId).parse(record.resourceId);
+      const schedule = z19.object({
+        enabled: z19.boolean(),
+        weekday: z19.number().int().min(1).max(7),
+        time: z19.string(),
+        timeZone: z19.string(),
+        revision: z19.number().int().min(0),
+        nextRunAt: z19.string().nullable()
       });
-      const notificationRoute = z22.object({
-        enabled: z22.boolean(),
-        minimumSeverity: z22.enum(["error", "warning"]),
-        includeFailures: z22.boolean(),
-        revision: z22.number().int().min(0),
-        destinationId: z22.string().nullable()
+      const notificationRoute = z19.object({
+        enabled: z19.boolean(),
+        minimumSeverity: z19.enum(["error", "warning"]),
+        includeFailures: z19.boolean(),
+        revision: z19.number().int().min(0),
+        destinationId: z19.string().nullable()
       });
       if (retryNotification) {
-        z22.literal(true).parse(record.retryQueued);
-        z22.literal(positionals[2]).parse(record.notificationId);
+        z19.literal(true).parse(record.retryQueued);
+        z19.literal(positionals[2]).parse(record.notificationId);
       } else if (route === "notifications destinations")
-        z22.object({
-          candidates: z22.array(
-            z22.object({
-              candidateId: z22.string(),
-              label: z22.string(),
-              availability: z22.literal("available")
+        z19.object({
+          candidates: z19.array(
+            z19.object({
+              candidateId: z19.string(),
+              label: z19.string(),
+              availability: z19.literal("available")
             })
           )
         }).parse(record);
@@ -11737,46 +10055,46 @@ async function runSeoCommand(options) {
         notificationRoute.parse(record.route);
       }
     } else if (!writing) {
-      const validated = z22.object({
-        resource: z22.object({
-          id: z22.literal(context.resourceId),
-          organizationId: z22.literal(context.overview.project.organizationId)
+      const validated = z19.object({
+        resource: z19.object({
+          id: z19.literal(context.resourceId),
+          organizationId: z19.literal(context.overview.project.organizationId)
         }),
-        audits: z22.array(z22.object({ id: z22.string() }).passthrough()),
-        audit: z22.object({
-          id: z22.string(),
-          resourceId: z22.literal(context.resourceId)
+        audits: z19.array(z19.object({ id: z19.string() }).passthrough()),
+        audit: z19.object({
+          id: z19.string(),
+          resourceId: z19.literal(context.resourceId)
         }).passthrough().nullable(),
-        pages: z22.array(z22.unknown()),
-        issues: z22.array(z22.unknown()),
-        changes: z22.array(z22.unknown()),
-        totalChanges: z22.number(),
-        dispositions: z22.array(z22.unknown())
+        pages: z19.array(z19.unknown()),
+        issues: z19.array(z19.unknown()),
+        changes: z19.array(z19.unknown()),
+        totalChanges: z19.number(),
+        dispositions: z19.array(z19.unknown())
       }).passthrough().parse(record);
       const selected = query.get("audit");
       if (selected && validated.audit?.id !== selected)
         throw new Error("The SEO response does not match the requested audit.");
     } else if (record.audit)
-      z22.object({
-        id: z22.string(),
-        resourceId: z22.literal(context.resourceId),
-        organizationId: z22.literal(context.overview.project.organizationId),
-        state: z22.literal("queued")
+      z19.object({
+        id: z19.string(),
+        resourceId: z19.literal(context.resourceId),
+        organizationId: z19.literal(context.overview.project.organizationId),
+        state: z19.literal("queued")
       }).parse(record.audit);
-    else if (route === "audit cancel") z22.literal(true).parse(record.cancelled);
+    else if (route === "audit cancel") z19.literal(true).parse(record.cancelled);
     else if (action === "issue")
-      z22.object({
-        url: z22.literal(values.url),
-        ruleId: z22.literal(values.rule),
-        ignored: z22.literal(positionals[1] === "ignore"),
-        revision: z22.literal(Number(values.revision) + 1)
+      z19.object({
+        url: z19.literal(values.url),
+        ruleId: z19.literal(values.rule),
+        ignored: z19.literal(positionals[1] === "ignore"),
+        revision: z19.literal(Number(values.revision) + 1)
       }).parse(record.disposition);
     else throw new Error("The SEO service returned an invalid response.");
     return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z22.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+      message: cause instanceof z19.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -11831,7 +10149,7 @@ function rootCommandRegistry() {
       fetchImpl: globalThis.fetch
     }),
     "health-check": runHealthCheck,
-    project: (args2) => runProjectCommand4({
+    project: (args2) => runProjectCommand({
       args: args2,
       cwd: process.cwd(),
       env: process.env,