harness-mcp-v2 3.2.19 → 3.2.21

package/build/registry/toolsets/feature-flags.js

@@ -1,24 +1,105 @@
-import { passthrough, fmeListExtract, fmeGetExtract } from "../extractors.js";
+import { passthrough, fmeListExtract, fmeGetExtract, fmeV4PaginatedListExtract } from "../extractors.js";
+import { isFmeHarnessNativeSelected, logFmeDeprecation, requireFmeIdentifier, requireHarnessNativeSegmentScope, resolveFmeDualMode } from "../scope-utils.js";
 const fmeActionExtract = (raw) => {
     if (raw !== null && typeof raw === "object" && !Array.isArray(raw))
         return raw;
     return { success: true, result: raw };
 };
+// The confirmed Harness-native FME v4 API (/fme/api/v4/...) does not use the
+// standard NG orgIdentifier/projectIdentifier query param convention — it expects
+// account_id/organization_identifier/project_identifier instead (confirmed live
+// against qa.harness.io). Applied per-route (never resource-level) on dual-mode
+// resources so the legacy Split.io branch's wire format stays untouched.
+const FME_HARNESS_NATIVE_SCOPE_PARAMS = {
+    account: "account_id",
+    org: "organization_identifier",
+    project: "project_identifier",
+};
+// Harness-native v4 create bodies (CreateFeatureFlagRequest/CreateSegmentRequest,
+// confirmed against Harness_Split/Main) accept tags as [{name: string}]; callers
+// commonly pass bare strings instead, so normalize the same way update already does.
+function normalizeFmeTags(tags) {
+    return Array.isArray(tags) ? tags.map((t) => (typeof t === "string" ? { name: t } : t)) : tags;
+}
+const FME_SEGMENT_TYPES = ["standard", "rule_based", "large"];
 const fmeFeatureFlagUpdateSchema = {
-    description: "Partial update for an FME feature flag's metadata. Provide the fields you want to change — they are converted to JSON Patch (RFC 6902) operations automatically.",
+    description: "Partial update for an FME feature flag's metadata. Provide the fields you want to change. Legacy mode (workspace_id): converted to JSON Patch (RFC 6902) automatically — description/tags/rolloutStatus only. Harness-native mode (org_id+project_id): sent as JSON Merge Patch (RFC 7396) — description/tags/owners/rolloutStatus; set description/tags/owners to null (or [] for tags/owners) to clear them, omit a field to leave it unchanged.",
     fields: [
         { name: "description", type: "string", required: false, description: "Updated description" },
         { name: "tags", type: "array", required: false, description: "Updated tags — provide as [{name: 'tag1'}] or ['tag1', 'tag2'] (strings are auto-wrapped)", itemType: "object" },
+        { name: "owners", type: "array", required: false, description: "Harness-native mode only. Updated owners — each entry is {type: \"USER\", id or email} or {type: \"GROUP\", identifier}", itemType: "object" },
         { name: "rolloutStatus", type: "object", required: false, description: "Rollout status — provide as {id: '<uuid>'} (use fme_rollout_status to discover valid IDs)" },
     ],
 };
 const fmeFeatureFlagCreateSchema = {
-    description: "Create a new feature flag (split) in a workspace under a specific traffic type. Note: the Split API does not support tags on create — use harness_update to add tags after creation.",
+    description: "Create a new feature flag. Legacy mode (workspace_id + traffic_type_id): name required, description optional — tags/owners not supported on create (the Split API has no create-time support; use harness_update after creation). Harness-native mode (org_id+project_id): name and trafficType required, description/tags/owners optional.",
     fields: [
-        { name: "name", type: "string", required: true, description: "Feature flag name (must be unique within the workspace)" },
+        { name: "name", type: "string", required: true, description: "Feature flag name (must be unique within the workspace/project)" },
         { name: "description", type: "string", required: false, description: "Optional description of the feature flag" },
+        { name: "trafficType", type: "string", required: false, description: "Traffic type name. Required in Harness-native (org_id+project_id) mode; also accepted as top-level traffic_type_id or traffic_type. Ignored in legacy mode (pass traffic_type_id as a path param there instead)" },
+        { name: "tags", type: "array", required: false, description: "Harness-native mode only. Each entry is {name: string}; bare strings are accepted and auto-wrapped", itemType: "object" },
+        { name: "owners", type: "array", required: false, description: "Harness-native mode only. Each entry is {type: \"USER\", id or email} or {type: \"GROUP\", identifier}", itemType: "object" },
+    ],
+};
+const fmeFeatureFlagKillRestoreReallocateSchema = {
+    description: "Optional comment and/or title recorded with the action. Both fields are accepted in legacy (workspace_id) and Harness-native (org_id+project_id) mode.",
+    fields: [
+        { name: "comment", type: "string", required: false, description: "Optional comment explaining the change" },
+        { name: "title", type: "string", required: false, description: "Optional short title for the change" },
+    ],
+};
+const fmeFeatureFlagArchiveSchema = {
+    description: "Optional comment recorded with the action.",
+    fields: [
+        { name: "comment", type: "string", required: false, description: "Optional comment explaining the change" },
+    ],
+};
+const fmeEnvironmentCreateSchema = {
+    description: "Create an FME environment (Harness-native org_id+project_id only). name is required (max 15 characters). isProduction is optional (default false). production is accepted as an alias for isProduction.",
+    fields: [
+        { name: "name", type: "string", required: true, description: "Environment name (unique in the project; max 15 characters)" },
+        { name: "isProduction", type: "boolean", required: false, description: "Whether this is a production environment. Optional; defaults to false on the backend if omitted." },
+        { name: "production", type: "boolean", required: false, description: "Alias for isProduction." },
     ],
 };
+const fmeEnvironmentUpdateSchema = {
+    description: "Partial environment update via JSON Merge Patch (RFC 7396), Harness-native only. name and isProduction are not clearable — omit to leave unchanged. production is accepted as an alias for isProduction.",
+    fields: [
+        { name: "name", type: "string", required: false, description: "Updated name; omit to leave unchanged. Blank names are rejected. Not clearable." },
+        { name: "isProduction", type: "boolean", required: false, description: "Updated production flag. Omit to leave unchanged; not clearable." },
+        { name: "production", type: "boolean", required: false, description: "Alias for isProduction." },
+    ],
+};
+function fmeEnvironmentProduction(body) {
+    if (!body)
+        return undefined;
+    if (body.isProduction !== undefined && body.isProduction !== null)
+        return Boolean(body.isProduction);
+    if (body.production !== undefined && body.production !== null)
+        return Boolean(body.production);
+    return undefined;
+}
+/** MCP never had workspace_id get/create/update/delete for environments (#806 list-only). */
+function resolveNativeOnlyEnvironmentRoute(input, operation, opts = {}) {
+    const mode = resolveFmeDualMode(input, "fme_environment");
+    if (mode.mode === "legacy") {
+        throw new Error(`fme_environment.${operation}: Harness-native (org_id/project_id) only — MCP never supported workspace_id for this operation (list remains dual-mode).`);
+    }
+    if (opts.collection) {
+        return {
+            path: "/fme/api/v4/environments",
+            product: "harness",
+            scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+        };
+    }
+    const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_environment"));
+    return {
+        path: `/fme/api/v4/environments/${environmentId}`,
+        product: "harness",
+        scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+        ...(opts.mergePatch ? { headers: { "Content-Type": "application/merge-patch+json" } } : {}),
+    };
+}
 const fmeFeatureFlagDefinitionCreateSchema = {
     description: "Create a feature flag definition in a specific environment (initial treatments, rules, and default rule required)",
     fields: [
@@ -29,6 +110,7 @@ const fmeFeatureFlagDefinitionCreateSchema = {
         { name: "baselineTreatment", type: "string", required: false, description: "The baseline (control) treatment for experimentation" },
         { name: "trafficAllocation", type: "number", required: false, description: "Percentage of traffic to include (0–100)" },
         { name: "comment", type: "string", required: false, description: "Comment describing the change" },
+        { name: "title", type: "string", required: false, description: "Harness-native mode only. Optional definition title." },
     ],
 };
 const fmeFeatureFlagDefinitionUpdateSchema = {
@@ -41,6 +123,7 @@ const fmeFeatureFlagDefinitionUpdateSchema = {
         { name: "defaultRule", type: "array", required: false, description: "Default rule buckets (treatment/size pairs) applied when no targeting rules match", itemType: "object" },
         { name: "trafficAllocation", type: "number", required: false, description: "Percentage of traffic to include (0–100)" },
         { name: "comment", type: "string", required: false, description: "Comment describing the change" },
+        { name: "title", type: "string", required: false, description: "Harness-native mode only. Optional definition title." },
     ],
 };
 const fmeRbsCreateSchema = {
@@ -50,6 +133,25 @@ const fmeRbsCreateSchema = {
         { name: "description", type: "string", required: false, description: "Optional segment description" },
     ],
 };
+const fmeSegmentCreateSchema = {
+    description: "Create a new segment. name, trafficType, and type are required; description/tags/owners are optional.",
+    fields: [
+        { name: "name", type: "string", required: true, description: "Segment name (must be unique within the project)" },
+        { name: "type", type: "string", required: true, description: "Segment kind. Must be one of: \"standard\" | \"rule_based\" | \"large\"." },
+        { name: "description", type: "string", required: false, description: "Optional description of the segment" },
+        { name: "trafficType", type: "string", required: true, description: "Traffic type name" },
+        { name: "tags", type: "array", required: false, description: "Each entry is {name: string}; bare strings are accepted and auto-wrapped", itemType: "object" },
+        { name: "owners", type: "array", required: false, description: "Each entry is {type: \"USER\", id or email} or {type: \"GROUP\", identifier}", itemType: "object" },
+    ],
+};
+const fmeSegmentDefinitionCreateSchema = {
+    description: "Create a segment definition in an environment. Omit the body (or send {}) to create an empty/default shell.",
+    fields: [{ name: "description", type: "string", required: false, description: "Optional description for the definition" }],
+};
+const fmeSegmentDefinitionUpdateSchema = {
+    description: "Update a segment definition via JSON Merge Patch (RFC 7396). description is the only mutable field: omit it to leave unchanged, pass null to clear it, or a string to set it.",
+    fields: [{ name: "description", type: "string", required: false, description: "Omit to keep the current value, null to clear it, or a string to set it" }],
+};
 const fmeRbsUpdateDefinitionSchema = {
     description: "Update a rule-based segment definition in an environment. Rules use: {condition: {combiner: 'AND', matchers: [{type, attribute, ...}]}}. Matcher types: IN_LIST_STRING (strings:[]), GREATER_THAN_OR_EQUAL_NUMBER (number:N), LESS_THAN_OR_EQUAL_NUMBER (number:N), BETWEEN_NUMBER (between:{from,to}), BOOLEAN (bool:true/false), ON_DATE (date:ms), IN_SPLIT (depends:{splitName,treatment}). Combiner values: AND, OR.",
     fields: [
@@ -92,10 +194,35 @@ const fmeRbsChangeRequestSchema = {
         },
     ],
 };
+function resolveNativeOnlyDefinitionRoute(input, operation, opts = {}) {
+    const mode = resolveFmeDualMode(input, "fme_feature_flag_definition");
+    if (mode.mode === "legacy") {
+        throw new Error(`fme_feature_flag_definition.${operation}: Harness-native (org_id/project_id) only — pass org_id+project_id instead of workspace_id.`);
+    }
+    if (opts.collection) {
+        requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag_definition");
+        return {
+            path: "/fme/api/v4/feature-flag-definitions",
+            product: "harness",
+            scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+        };
+    }
+    const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag_definition"));
+    requireFmeIdentifier(input, "environment_id", "fme_feature_flag_definition");
+    return {
+        path: `/fme/api/v4/feature-flag-definitions/${flagName}${opts.suffix ?? ""}`,
+        product: "harness",
+        scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+    };
+}
 export const featureFlagsToolset = {
     name: "feature-flags",
     displayName: "Feature Management & Experimentation",
-    description: "Harness FME — feature flags, rule-based segments, workspaces, environments, and rollout statuses via the Split.io API",
+    description: "Harness FME — feature flags, segments, environments, and rollout statuses. " +
+        "Two mutually exclusive scoping modes: legacy workspace_id (Split.io API) or " +
+        "Harness-native org_id+project_id. If you already have org_id and project_id, use " +
+        "them directly and skip fme_workspace entirely — org/project fully identify scope " +
+        "on their own; there is no need to look up a workspace first.",
     resources: [
         // ── FME Resources (Split.io API at https://api.split.io) ───────────
         // These use account scope to avoid injecting orgIdentifier/projectIdentifier
@@ -104,9 +231,14 @@ export const featureFlagsToolset = {
         {
             resourceType: "fme_workspace",
             displayName: "FME Workspace",
-            description: "Feature Management workspace. Supports list with pagination (offset/size, default 20, max 1000).",
+            description: "Feature Management workspace — legacy Split.io concept only, used solely to discover a " +
+                "workspace_id for other fme_* resources' deprecated legacy calls. Not used by Harness-native " +
+                "calls at all: if you already have org_id and project_id, skip this resource entirely and " +
+                "pass them directly to the fme_* resource you actually want. Supports list with pagination " +
+                "(offset/size, default 20, max 1000).",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id"],
             product: "fme",
             listFilterFields: [
@@ -116,6 +248,13 @@ export const featureFlagsToolset = {
                 list: {
                     method: "GET",
                     path: "/internal/api/v2/workspaces",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_workspace.list")) {
+                            throw new Error("fme_workspace: this resource has no Harness-native equivalent — it exists only to discover workspace_id values for the deprecated legacy contract.");
+                        }
+                        logFmeDeprecation("[DEPRECATION] fme_workspace: this resource and the workspace_id contract it supports are deprecated.");
+                        return { path: "/internal/api/v2/workspaces" };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
                     queryParams: {
                         offset: "offset",
@@ -129,37 +268,104 @@ export const featureFlagsToolset = {
         {
             resourceType: "fme_environment",
             displayName: "FME Environment",
-            description: "Feature Management environment. Supports list. Requires a workspace_id.",
+            description: "Feature Management environment. Dual-mode list (workspace_id or org_id+project_id). get/create/update/delete are Harness-native only. Native create/update use isProduction (production accepted as an alias). Native PATCH is JSON Merge Patch; name and isProduction are not clearable. Name max 15 characters. Delete returns 400 hasDependents while SDK API keys (always created with a new env), flags, or segments remain.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "environment_id"],
             product: "fme",
-            baseUrlOverride: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from harness_list resource_type=fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from harness_list resource_type=fme_workspace). Deprecated — omit and pass org_id+project_id instead for Harness-native scoping." },
+                { name: "offset", description: "Harness-native pagination offset (default 0)", type: "number" },
+                { name: "limit", description: "Harness-native page size (default 100, max 100)", type: "number" },
             ],
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/environments/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_environment");
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/environments/ws/${encodeURIComponent(mode.workspaceId)}` };
+                        }
+                        return { path: "/fme/api/v4/environments", product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
+                    queryParams: { offset: "offset", size: "limit", limit: "limit" },
+                    responseExtractor: fmeV4PaginatedListExtract,
+                    description: "List FME environments for a workspace (legacy) or org_id+project_id project (Harness-native). Native envelope {data, limit, offset, totalCount} is promoted to items/total; harness_list size maps to limit.",
+                },
+                get: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyEnvironmentRoute(input, "get"),
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    responseExtractor: passthrough,
+                    description: "Get a single environment by environment_id (UUID from list). Harness-native only (org_id+project_id). MCP never supported workspace_id get.",
+                },
+                create: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyEnvironmentRoute(input, "create", { collection: true }),
+                    operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
+                    skipScopeBodyInjection: true,
+                    bodyBuilder: (input) => {
+                        const body = input.body;
+                        const production = fmeEnvironmentProduction(body);
+                        return {
+                            name: body?.name,
+                            ...(production !== undefined ? { isProduction: production } : {}),
+                        };
+                    },
                     responseExtractor: passthrough,
-                    description: "List FME environments for a workspace",
+                    bodySchema: fmeEnvironmentCreateSchema,
+                    description: "Create an environment (Harness-native only). Body requires name (max 15 characters). Optional isProduction (CreateEnvironmentRequest). NG scope is not injected into the JSON.",
+                },
+                update: {
+                    method: "PATCH",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyEnvironmentRoute(input, "update", { mergePatch: true }),
+                    operationPolicy: { risk: "low_write", retryPolicy: "safe" },
+                    skipScopeBodyInjection: true,
+                    bodyBuilder: (input) => {
+                        const body = input.body;
+                        if (!body)
+                            return {};
+                        const production = fmeEnvironmentProduction(body);
+                        return {
+                            ...(typeof body.name === "string" ? { name: body.name } : {}),
+                            ...(production !== undefined ? { isProduction: production } : {}),
+                        };
+                    },
+                    responseExtractor: passthrough,
+                    bodySchema: fmeEnvironmentUpdateSchema,
+                    description: "Update an environment by environment_id (Harness-native only). JSON Merge Patch on name and isProduction (not clearable).",
+                },
+                delete: {
+                    method: "DELETE",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyEnvironmentRoute(input, "delete"),
+                    operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
+                    responseExtractor: passthrough,
+                    description: "Delete (archive) an environment by environment_id (Harness-native only). Returns 400 hasDependents while SDK API keys, flags, or segments still target it. Create via EnvironmentStarterKit always provisions client/server API keys, so a brand-new environment cannot be deleted until those keys are removed.",
                 },
             },
         },
         {
             resourceType: "fme_feature_flag",
             displayName: "FME Feature Flag",
-            description: "Feature flag via the Split.io API. List flags by workspace with filtering (name, tags, rollout_status_id) and pagination (offset/size, default 20, max 50). Supports create (requires traffic_type_id), get, delete, update, and kill/restore/archive/unarchive execute actions.",
+            description: "Feature flag. Dual-mode scoping: pass org_id+project_id (Harness-native, preferred — no " +
+                "workspace lookup needed) or the deprecated workspace_id (Split.io API). Both modes support " +
+                "list/get/create/delete/update/kill/restore/reallocate/archive/unarchive. List supports " +
+                "filtering (name, tags, rollout_status_id) and pagination (offset/size, default 20, max 50).",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "feature_flag_name"],
             product: "fme",
             deepLinkTemplate: "/ng/account/{accountId}/module/fme/orgs/{orgIdentifier}/projects/{projectIdentifier}/setup/resources/targets/{trafficTypeId}/splits/{id}",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from harness_list resource_type=fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from harness_list resource_type=fme_workspace). Deprecated — omit and pass org_id+project_id instead for Harness-native scoping." },
                 { name: "offset", description: "Pagination offset for FME feature flags", type: "number" },
                 { name: "rollout_status_id", description: "Filter by rollout status UUID (use fme_rollout_status to discover valid IDs)", type: "string" },
                 { name: "name", description: "Filter flags by name (partial match)", type: "string" },
@@ -168,9 +374,15 @@ export const featureFlagsToolset = {
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/splits/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}` };
+                        }
+                        return { path: "/fme/api/v4/feature-flags", product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
                     queryParams: {
                         offset: "offset",
                         size: "limit",
@@ -179,23 +391,54 @@ export const featureFlagsToolset = {
                         tags: "tag",
                     },
                     responseExtractor: fmeListExtract,
-                    description: "List feature flags for a workspace with filtering and pagination (offset and size params, max 50).",
+                    description: "List feature flags by workspace_id (legacy, deprecated) or org_id+project_id (Harness-native), with filtering and pagination (offset and size params, max 50).",
                 },
                 get: {
                     method: "GET",
-                    path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}` };
+                        }
+                        return { path: `/fme/api/v4/feature-flags/${flagName}`, product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId", feature_flag_name: "featureFlagName" },
                     responseExtractor: fmeGetExtract,
-                    description: "Get a specific feature flag's metadata without requiring an environment",
+                    description: "Get a specific feature flag's metadata without requiring an environment (legacy: workspace_id; Harness-native: org_id+project_id).",
                 },
                 create: {
                     method: "POST",
                     path: "/internal/api/v2/splits/ws/{wsId}/trafficTypes/{trafficTypeId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        if (mode.mode === "harness_native") {
+                            return { path: "/fme/api/v4/feature-flags", product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/trafficTypes/${encodeURIComponent(requireFmeIdentifier(input, "traffic_type_id", "fme_feature_flag"))}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
                     pathParams: { workspace_id: "wsId", traffic_type_id: "trafficTypeId" },
                     bodyBuilder: (input) => {
                         const body = input.body;
+                        if (isFmeHarnessNativeSelected(input, "fme_feature_flag")) {
+                            const trafficType = (body?.trafficType ?? input.traffic_type_id ?? input.traffic_type ?? body?.traffic_type);
+                            if (!trafficType) {
+                                throw new Error('fme_feature_flag.create: "trafficType" is required in Harness-native mode — pass body.trafficType, traffic_type_id, or traffic_type.');
+                            }
+                            const name = body?.name ?? input.name;
+                            if (!name) {
+                                throw new Error('fme_feature_flag.create: "name" is required in Harness-native mode — pass body.name.');
+                            }
+                            return {
+                                name,
+                                trafficType,
+                                ...(body?.description !== undefined ? { description: body.description } : {}),
+                                ...(body?.tags !== undefined ? { tags: normalizeFmeTags(body.tags) } : {}),
+                                ...(body?.owners !== undefined ? { owners: body.owners } : {}),
+                            };
+                        }
                         return {
                             name: body?.name ?? input.name,
                             ...(body?.description || input.description ? { description: body?.description ?? input.description } : {}),
@@ -203,23 +446,56 @@ export const featureFlagsToolset = {
                     },
                     responseExtractor: passthrough,
                     bodySchema: fmeFeatureFlagCreateSchema,
-                    description: "Create a feature flag in a workspace. Requires workspace_id and traffic_type_id (get from fme_traffic_type). Body requires name, optional description. Note: tags must be set via a follow-up harness_update call (Split API limitation).",
+                    description: "Create a feature flag. Legacy mode (workspace_id): requires workspace_id + traffic_type_id (get from fme_traffic_type); body: name, optional description (no tags/owners — use harness_update after creation). Harness-native mode (org_id+project_id): body requires name + trafficType (or pass traffic_type_id / traffic_type at top level), optional description/tags/owners.",
                 },
                 delete: {
                     method: "DELETE",
-                    path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}` };
+                        }
+                        return { path: `/fme/api/v4/feature-flags/${flagName}`, product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
-                    pathParams: { workspace_id: "wsId", feature_flag_name: "featureFlagName" },
                     responseExtractor: passthrough,
-                    description: "Delete a feature flag from a workspace",
+                    description: "Delete a feature flag from a workspace (legacy) or org_id+project_id-scoped project (Harness-native)",
                 },
                 update: {
                     method: "PATCH",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flags/${flagName}`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                                headers: { "Content-Type": "application/merge-patch+json" },
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "safe" },
                     pathParams: { workspace_id: "wsId", feature_flag_name: "featureFlagName" },
                     bodyBuilder: (input) => {
                         const body = input.body;
+                        if (isFmeHarnessNativeSelected(input, "fme_feature_flag")) {
+                            // JSON Merge Patch (RFC 7396): omit a field to leave it unchanged, set it to update,
+                            // or (for description/tags/owners) set it to null/[] to clear it. rolloutStatus is
+                            // set-only — the backend rejects an explicit null for it.
+                            if (!body)
+                                return {};
+                            return {
+                                ...(body.description !== undefined ? { description: body.description } : {}),
+                                ...(body.tags !== undefined ? { tags: body.tags === null ? null : normalizeFmeTags(body.tags) } : {}),
+                                ...(body.owners !== undefined ? { owners: body.owners } : {}),
+                                ...(body.rolloutStatus !== undefined ? { rolloutStatus: body.rolloutStatus } : {}),
+                            };
+                        }
                         if (!body)
                             return [];
                         const ops = [];
@@ -242,7 +518,7 @@ export const featureFlagsToolset = {
                         return ops;
                     },
                     responseExtractor: passthrough,
-                    description: "Update a feature flag's metadata (description, tags, rolloutStatus). Uses JSON Patch (RFC 6902) format — provide fields directly and they are converted to patch operations automatically.",
+                    description: "Update a feature flag's metadata. Legacy mode (workspace_id): description/tags/rolloutStatus via JSON Patch (RFC 6902) — provide fields directly, they're converted to patch ops automatically. Harness-native mode (org_id+project_id): description/tags/owners/rolloutStatus via JSON Merge Patch (RFC 7396) — omit a field to leave it unchanged, set it to update, or set description/tags/owners to null (or [] for tags/owners) to clear it; rolloutStatus is set-only (no null).",
                     bodySchema: fmeFeatureFlagUpdateSchema,
                 },
             },
@@ -250,172 +526,409 @@ export const featureFlagsToolset = {
                 kill: {
                     method: "PUT",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}/kill",
+                    methodBuilder: (input) => (isFmeHarnessNativeSelected(input, "fme_feature_flag") ? "POST" : "PUT"),
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flag-definitions/${flagName}/kill`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}/kill` };
+                    },
                     operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
                     pathParams: {
                         workspace_id: "wsId",
                         feature_flag_name: "featureFlagName",
                         environment_id: "environmentId",
                     },
-                    bodyBuilder: () => ({}),
-                    responseExtractor: fmeActionExtract,
-                    actionDescription: "Kill (turn off) a feature flag in a specific environment. Requires workspace_id, feature_flag_name, and environment_id.",
-                    bodySchema: {
-                        description: "No body required — identifiers are in path/query params.",
-                        fields: [],
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
                     },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Kill (turn off) a feature flag in a specific environment. Requires feature_flag_name and environment_id, plus workspace_id (legacy) or org_id+project_id (Harness-native). Optional comment/title recorded with the change.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
                 },
                 restore: {
                     method: "PUT",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}/restore",
+                    methodBuilder: (input) => (isFmeHarnessNativeSelected(input, "fme_feature_flag") ? "POST" : "PUT"),
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flag-definitions/${flagName}/restore`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}/restore` };
+                    },
                     operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
                     pathParams: {
                         workspace_id: "wsId",
                         feature_flag_name: "featureFlagName",
                         environment_id: "environmentId",
                     },
-                    bodyBuilder: () => ({}),
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
+                    },
                     responseExtractor: fmeActionExtract,
-                    actionDescription: "Restore (re-enable) a killed feature flag in a specific environment. Requires workspace_id, feature_flag_name, and environment_id.",
-                    bodySchema: {
-                        description: "No body required — identifiers are in path/query params.",
-                        fields: [],
+                    actionDescription: "Restore (re-enable) a killed feature flag in a specific environment. Requires feature_flag_name and environment_id, plus workspace_id (legacy) or org_id+project_id (Harness-native). Optional comment/title recorded with the change.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
+                },
+                reallocate: {
+                    method: "POST",
+                    path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}/reallocate",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flag-definitions/${flagName}/reallocate`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}/reallocate` };
+                    },
+                    operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
+                    pathParams: {
+                        workspace_id: "wsId",
+                        feature_flag_name: "featureFlagName",
+                        environment_id: "environmentId",
+                    },
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
                     },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Reallocate traffic across treatments for a feature flag in a specific environment, without a full targeting-rules update. Requires feature_flag_name and environment_id, plus workspace_id (legacy) or org_id+project_id (Harness-native). Optional comment/title recorded with the change.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
                 },
                 archive: {
                     method: "POST",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/archive",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flags/${flagName}/archive`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/archive` };
+                    },
                     operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
                     pathParams: { workspace_id: "wsId", feature_flag_name: "featureFlagName" },
-                    bodyBuilder: () => ({}),
-                    responseExtractor: fmeActionExtract,
-                    actionDescription: "Archive a feature flag. Requires workspace_id and feature_flag_name. Subject to OPA policy checks (409 on failure).",
-                    bodySchema: {
-                        description: "No body required for this action.",
-                        fields: [],
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return body.comment !== undefined ? { comment: body.comment } : {};
                     },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Archive a feature flag. Requires feature_flag_name, plus workspace_id (legacy) or org_id+project_id (Harness-native). Subject to OPA policy checks (409 on failure). Optional comment recorded with the change.",
+                    bodySchema: fmeFeatureFlagArchiveSchema,
                 },
                 unarchive: {
                     method: "POST",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/unarchive",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flags/${flagName}/unarchive`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/unarchive` };
+                    },
                     operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
                     pathParams: { workspace_id: "wsId", feature_flag_name: "featureFlagName" },
-                    bodyBuilder: () => ({}),
-                    responseExtractor: fmeActionExtract,
-                    actionDescription: "Unarchive a previously archived feature flag. Requires workspace_id and feature_flag_name. Returns 409 if the flag has dependent objects.",
-                    bodySchema: {
-                        description: "No body required for this action.",
-                        fields: [],
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return body.comment !== undefined ? { comment: body.comment } : {};
                     },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Unarchive a previously archived feature flag. Requires feature_flag_name, plus workspace_id (legacy) or org_id+project_id (Harness-native). Returns 409 if the flag has dependent objects. Optional comment recorded with the change.",
+                    bodySchema: fmeFeatureFlagArchiveSchema,
                 },
             },
         },
         {
             resourceType: "fme_feature_flag_definition",
             displayName: "FME Feature Flag Definition",
-            description: "Detailed definition of a feature flag in a specific environment, including treatments, rules, targeting, and traffic allocation. Supports create, get, and update. Create requires treatments, defaultTreatment, and defaultRule.",
+            description: "Detailed definition of a feature flag in a specific environment: treatments, rules, targeting, and traffic allocation. Create requires treatments, defaultTreatment, and defaultRule. Get/create/update: pass org_id+project_id (preferred) or the deprecated workspace_id. List/delete/kill/restore/reallocate: org_id+project_id only. Native list requires feature_flag_name and uses offset/limit (max 100); it does not take environment_id. Other ops require environment_id. Kill/restore/reallocate are the same actions as on fme_feature_flag; either resource works.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "environment_id", "feature_flag_name"],
             product: "fme",
+            listFilterFields: [
+                { name: "feature_flag_name", description: "Feature flag name whose definitions to list. Required.", required: true },
+                { name: "offset", description: "Pagination offset (default 0)", type: "number" },
+                { name: "limit", description: "Page size (default 100, max 100)", type: "number" },
+            ],
             operations: {
+                list: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyDefinitionRoute(input, "list", { collection: true }),
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    queryParams: { feature_flag_name: "feature_flag_name", offset: "offset", limit: "limit" },
+                    responseExtractor: passthrough,
+                    description: "List feature flag definitions for a flag across environments (org_id+project_id only). Requires feature_flag_name. Pagination uses offset and limit (default 100, max 100). Do not pass environment_id.",
+                },
                 get: {
                     method: "GET",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag_definition");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag_definition"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag_definition"));
+                        if (mode.mode === "harness_native") {
+                            return { path: `/fme/api/v4/feature-flag-definitions/${flagName}`, product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
                     pathParams: {
                         workspace_id: "wsId",
                         feature_flag_name: "featureFlagName",
                         environment_id: "environmentId",
                     },
+                    queryParams: { environment_id: "environment_id" },
                     responseExtractor: passthrough,
-                    description: "Get feature flag definition in a specific environment (treatments, rules, default rule, traffic allocation)",
+                    description: "Get a feature flag definition in a specific environment (treatments, rules, default rule, traffic allocation). Requires feature_flag_name and environment_id. Pass org_id+project_id (preferred) or deprecated workspace_id.",
                 },
                 create: {
                     method: "POST",
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag_definition");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag_definition"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag_definition"));
+                        if (mode.mode === "harness_native") {
+                            return { path: `/fme/api/v4/feature-flag-definitions/${flagName}`, product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
                     pathParams: {
                         workspace_id: "wsId",
                         feature_flag_name: "featureFlagName",
                         environment_id: "environmentId",
                     },
+                    queryParams: { environment_id: "environment_id" },
                     bodyBuilder: (input) => input.body,
                     responseExtractor: passthrough,
                     bodySchema: fmeFeatureFlagDefinitionCreateSchema,
-                    description: "Create a feature flag definition in a specific environment. Requires treatments (array of treatment objects), defaultTreatment (string matching a treatment name), and defaultRule (array of bucket objects). Optional: rules, baselineTreatment, trafficAllocation, comment.",
+                    description: "Create a feature flag definition in a specific environment. Requires treatments (array of treatment objects), defaultTreatment (string matching a treatment name), and defaultRule (array of bucket objects). Optional: rules, baselineTreatment, trafficAllocation, comment, title (Harness-native only). Requires feature_flag_name and environment_id. Pass org_id+project_id (preferred) or deprecated workspace_id.",
                 },
                 update: {
                     method: "PUT",
+                    methodBuilder: (input) => (isFmeHarnessNativeSelected(input, "fme_feature_flag_definition") ? "PATCH" : "PUT"),
                     path: "/internal/api/v2/splits/ws/{wsId}/{featureFlagName}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_feature_flag_definition");
+                        const flagName = encodeURIComponent(requireFmeIdentifier(input, "feature_flag_name", "fme_feature_flag_definition"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_feature_flag_definition"));
+                        if (mode.mode === "harness_native") {
+                            return {
+                                path: `/fme/api/v4/feature-flag-definitions/${flagName}`,
+                                product: "harness",
+                                scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+                                headers: { "Content-Type": "application/merge-patch+json" },
+                            };
+                        }
+                        return { path: `/internal/api/v2/splits/ws/${encodeURIComponent(mode.workspaceId)}/${flagName}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "safe" },
                     pathParams: {
                         workspace_id: "wsId",
                         feature_flag_name: "featureFlagName",
                         environment_id: "environmentId",
                     },
+                    queryParams: { environment_id: "environment_id" },
                     bodyBuilder: (input) => input.body,
                     responseExtractor: passthrough,
                     bodySchema: fmeFeatureFlagDefinitionUpdateSchema,
-                    description: "Update a feature flag definition in a specific environment (treatments, rules, default rule, traffic allocation, baseline treatment)",
+                    description: "Update a feature flag definition in a specific environment (treatments, rules, default rule, traffic allocation, baseline treatment). Requires feature_flag_name and environment_id. Pass org_id+project_id (preferred) or deprecated workspace_id. Native update is JSON Merge Patch: omit a field to leave it unchanged; treatments/rules/defaultRule are omit-to-keep but reject explicit null (not clearable). Legacy update is a full replace.",
+                },
+                delete: {
+                    method: "DELETE",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyDefinitionRoute(input, "delete"),
+                    operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    responseExtractor: passthrough,
+                    description: "Delete a feature flag definition in an environment (org_id+project_id only). Requires feature_flag_name and environment_id.",
+                },
+            },
+            executeActions: {
+                kill: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyDefinitionRoute(input, "kill", { suffix: "/kill" }),
+                    operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
+                    },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Kill (turn off) a feature flag definition in an environment (org_id+project_id only). Requires feature_flag_name and environment_id. Optional body comment/title. Same action as fme_feature_flag kill.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
+                },
+                restore: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyDefinitionRoute(input, "restore", { suffix: "/restore" }),
+                    operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
+                    },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Restore a killed feature flag definition in an environment (org_id+project_id only). Requires feature_flag_name and environment_id. Optional body comment/title. Same action as fme_feature_flag restore.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
+                },
+                reallocate: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => resolveNativeOnlyDefinitionRoute(input, "reallocate", { suffix: "/reallocate" }),
+                    operationPolicy: { risk: "high_write", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body ?? {};
+                        return {
+                            ...(body.comment !== undefined ? { comment: body.comment } : {}),
+                            ...(body.title !== undefined ? { title: body.title } : {}),
+                        };
+                    },
+                    responseExtractor: fmeActionExtract,
+                    actionDescription: "Reallocate traffic across treatments for a feature flag definition in an environment (org_id+project_id only). Requires feature_flag_name and environment_id. Optional body comment/title. Same action as fme_feature_flag reallocate.",
+                    bodySchema: fmeFeatureFlagKillRestoreReallocateSchema,
                 },
             },
         },
         {
             resourceType: "fme_rollout_status",
             displayName: "FME Rollout Status",
-            description: "Rollout status definitions for a workspace (e.g. Killed, Permanent, Ramping). Use to discover valid rollout_status_id UUIDs for filtering fme_feature_flag lists. Note: this endpoint may not be available on all account types — rollout status IDs are also returned inline with fme_feature_flag list results.",
+            description: "Rollout status definitions (e.g. Killed, Permanent, Ramping). Dual-mode: pass org_id+project_id (preferred) or the deprecated workspace_id. Use harness_list to discover rollout_status_id UUIDs for filtering fme_feature_flag lists. Pagination uses offset/limit (max 100; harness_list size maps to limit).",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id"],
             product: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace). Deprecated — omit and pass org_id+project_id instead for Harness-native scoping." },
+                { name: "offset", description: "Harness-native pagination offset (default 0)", type: "number" },
+                { name: "limit", description: "Harness-native page size (default 100, max 100)", type: "number" },
             ],
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/rolloutStatuses/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rollout_status");
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/rolloutStatuses/ws/${encodeURIComponent(mode.workspaceId)}` };
+                        }
+                        return { path: "/fme/api/v4/rollout-statuses", product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
-                    responseExtractor: passthrough,
-                    description: "List rollout status definitions for a workspace (Killed, Permanent, Ramping, etc.). If this returns 404, use rolloutStatus fields from fme_feature_flag list results instead.",
+                    queryParams: { offset: "offset", size: "limit", limit: "limit" },
+                    responseExtractor: fmeV4PaginatedListExtract,
+                    description: "List rollout statuses. Pass org_id+project_id (preferred) or deprecated workspace_id. Optional offset/limit (harness_list size maps to limit).",
                 },
             },
         },
         // ── FME Rule-Based Segments ───────────────────────────────────────────
         {
             resourceType: "fme_rule_based_segment",
-            displayName: "FME Rule-Based Segment",
-            description: "Rule-based segment in a workspace. Supports list, get, create (requires traffic_type_id), and delete. Create requires traffic_type_id passed via params.",
+            displayName: "(Deprecated) FME Rule-Based Segment",
+            description: "Deprecated — use fme_segment instead for new integrations. Rule-based segment in a workspace. Supports list, get, create (requires traffic_type_id), and delete via the legacy workspace_id contract only — org_id+project_id (Harness-native) is rejected on every operation here in favor of fme_segment. Create requires traffic_type_id passed via params.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "segment_name"],
             product: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace). This resource only supports the legacy workspace_id contract; use fme_segment for Harness-native org_id+project_id scoping." },
             ],
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/rule-based-segments/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment.list: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead.");
+                        }
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
                     responseExtractor: passthrough,
                     description: "List all rule-based segments in a workspace",
                 },
                 get: {
                     method: "GET",
-                    path: "/internal/api/v2/rule-based-segments/ws/{wsId}/{rbSegmentName}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment.get: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead.");
+                        }
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_rule_based_segment"));
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}/${segmentName}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId", segment_name: "rbSegmentName" },
                     responseExtractor: passthrough,
                     description: "Get a rule-based segment by name (workspace-level metadata)",
                 },
                 create: {
                     method: "POST",
-                    path: "/internal/api/v2/rule-based-segments/ws/{wsId}/trafficTypes/{trafficTypeId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment.create: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead (create is not yet implemented there either).");
+                        }
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}/trafficTypes/${encodeURIComponent(requireFmeIdentifier(input, "traffic_type_id", "fme_rule_based_segment"))}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
-                    pathParams: { workspace_id: "wsId", traffic_type_id: "trafficTypeId" },
                     bodyBuilder: (input) => {
                         const body = input.body;
                         return {
@@ -429,9 +942,16 @@ export const featureFlagsToolset = {
                 },
                 delete: {
                     method: "DELETE",
-                    path: "/internal/api/v2/rule-based-segments/ws/{wsId}/{rbSegmentName}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment.delete: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead.");
+                        }
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_rule_based_segment"));
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}/${segmentName}` };
+                    },
                     operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
-                    pathParams: { workspace_id: "wsId", segment_name: "rbSegmentName" },
                     responseExtractor: passthrough,
                     description: "Delete a rule-based segment from a workspace. Environment-level configs must be removed separately.",
                 },
@@ -439,20 +959,29 @@ export const featureFlagsToolset = {
         },
         {
             resourceType: "fme_rule_based_segment_definition",
-            displayName: "FME Rule-Based Segment Definition",
-            description: "Environment-specific definition of a rule-based segment, including targeting rules, exclusions, and matchers. Supports list (by environment), update, and enable/disable/change_request execute actions.",
+            displayName: "(Deprecated) FME Rule-Based Segment Definition",
+            description: "Deprecated — use fme_segment_definition instead for new integrations. Environment-specific definition of a rule-based segment, including targeting rules, exclusions, and matchers. Supports list (by environment), update, and enable/disable/change_request execute actions.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "environment_id", "segment_name"],
             product: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace). Deprecated — omit and pass org_id+project_id instead for Harness-native scoping." },
                 { name: "environment_id", description: "FME environment ID (get from fme_environment)", required: true },
             ],
             operations: {
                 list: {
                     method: "GET",
                     path: "/internal/api/v2/rule-based-segments/ws/{wsId}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment_definition");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment_definition.list: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment_definition instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_rule_based_segment_definition"));
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
                     pathParams: { workspace_id: "wsId", environment_id: "environmentId" },
                     responseExtractor: passthrough,
@@ -461,6 +990,15 @@ export const featureFlagsToolset = {
                 update: {
                     method: "PUT",
                     path: "/internal/api/v2/rule-based-segments/ws/{wsId}/{rbSegmentName}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment_definition");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment_definition.update: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment_definition instead.");
+                        }
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_rule_based_segment_definition"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_rule_based_segment_definition"));
+                        return { path: `/internal/api/v2/rule-based-segments/ws/${encodeURIComponent(mode.workspaceId)}/${segmentName}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "safe" },
                     pathParams: { workspace_id: "wsId", segment_name: "rbSegmentName", environment_id: "environmentId" },
                     bodyBuilder: (input) => input.body,
@@ -473,6 +1011,14 @@ export const featureFlagsToolset = {
                 enable: {
                     method: "POST",
                     path: "/internal/api/v2/rule-based-segments/{environmentId}/{rbSegmentName}",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_rule_based_segment_definition.enable")) {
+                            throw new Error("fme_rule_based_segment_definition.enable: Harness-native (org_id/project_id) mode is not supported on this deprecated resource, and fme_segment_definition has no enable equivalent either — pass environment_id/segment_name (legacy contract) instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_rule_based_segment_definition"));
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_rule_based_segment_definition"));
+                        return { path: `/internal/api/v2/rule-based-segments/${environmentId}/${segmentName}` };
+                    },
                     operationPolicy: { risk: "medium_write", retryPolicy: "do_not_retry" },
                     pathParams: { environment_id: "environmentId", segment_name: "rbSegmentName" },
                     bodyBuilder: () => ({}),
@@ -483,6 +1029,14 @@ export const featureFlagsToolset = {
                 disable: {
                     method: "DELETE",
                     path: "/internal/api/v2/rule-based-segments/{environmentId}/{rbSegmentName}",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_rule_based_segment_definition.disable")) {
+                            throw new Error("fme_rule_based_segment_definition.disable: Harness-native (org_id/project_id) mode is not supported on this deprecated resource, and fme_segment_definition has no disable equivalent either — pass environment_id/segment_name (legacy contract) instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_rule_based_segment_definition"));
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_rule_based_segment_definition"));
+                        return { path: `/internal/api/v2/rule-based-segments/${environmentId}/${segmentName}` };
+                    },
                     operationPolicy: { risk: "medium_write", retryPolicy: "do_not_retry" },
                     pathParams: { environment_id: "environmentId", segment_name: "rbSegmentName" },
                     responseExtractor: passthrough,
@@ -495,6 +1049,14 @@ export const featureFlagsToolset = {
                 change_request: {
                     method: "POST",
                     path: "/internal/api/v2/changeRequests/ws/{wsId}/environments/{environmentId}",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_rule_based_segment_definition");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_rule_based_segment_definition.change_request: Harness-native (org_id/project_id) mode is not supported on this deprecated resource, and fme_segment_definition has no change_request equivalent either — pass workspace_id (deprecated) instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_rule_based_segment_definition"));
+                        return { path: `/internal/api/v2/changeRequests/ws/${encodeURIComponent(mode.workspaceId)}/environments/${environmentId}` };
+                    },
                     operationPolicy: { risk: "medium_write", retryPolicy: "do_not_retry" },
                     pathParams: { workspace_id: "wsId", environment_id: "environmentId" },
                     bodyBuilder: (input) => ({
@@ -514,22 +1076,32 @@ export const featureFlagsToolset = {
         {
             resourceType: "fme_traffic_type",
             displayName: "FME Traffic Type",
-            description: "Traffic type in a workspace (e.g. 'user', 'account'). List traffic types to discover traffic_type_id values needed for identity queries and flag/segment creation.",
+            description: "Traffic type (e.g. 'user', 'account'). Dual-mode: pass org_id+project_id (preferred) or the deprecated workspace_id. Use harness_list to discover traffic_type_id / name values for flag and segment create. Pagination uses offset/limit (max 100; harness_list size maps to limit).",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id"],
             product: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace)", required: true },
+                { name: "workspace_id", description: "FME workspace ID (get from fme_workspace). Deprecated — omit and pass org_id+project_id instead for Harness-native scoping." },
+                { name: "offset", description: "Harness-native pagination offset (default 0)", type: "number" },
+                { name: "limit", description: "Harness-native page size (default 100, max 100)", type: "number" },
             ],
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/trafficTypes/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_traffic_type");
+                        if (mode.mode === "legacy") {
+                            return { path: `/internal/api/v2/trafficTypes/ws/${encodeURIComponent(mode.workspaceId)}` };
+                        }
+                        return { path: "/fme/api/v4/traffic-types", product: "harness", scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
-                    responseExtractor: passthrough,
-                    description: "List traffic types for a workspace. Returns id, name, and displayAttributeId for each traffic type.",
+                    queryParams: { offset: "offset", size: "limit", limit: "limit" },
+                    responseExtractor: fmeV4PaginatedListExtract,
+                    description: "List traffic types. Pass org_id+project_id (preferred) or deprecated workspace_id. Optional offset/limit (harness_list size maps to limit).",
                 },
             },
         },
@@ -540,14 +1112,29 @@ export const featureFlagsToolset = {
             description: "Identity (target) in an environment. Create or update identities to manage display name aliases and custom attributes. Requires traffic_type_id and environment_id. Note: the Split Admin API does not support listing or getting individual identities — use create (batch upsert) and update (PATCH single key).",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["traffic_type_id", "environment_id", "key"],
             product: "fme",
             operations: {
                 create: {
                     method: "POST",
                     path: "/internal/api/v2/trafficTypes/{trafficTypeId}/environments/{environmentId}/identities",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_identity.create")) {
+                            throw new Error("fme_identity.create: Harness-native (org_id/project_id) mode not yet implemented for this operation — pass traffic_type_id/environment_id (current contract) instead.");
+                        }
+                        const trafficTypeId = encodeURIComponent(requireFmeIdentifier(input, "traffic_type_id", "fme_identity"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_identity"));
+                        return { path: `/internal/api/v2/trafficTypes/${trafficTypeId}/environments/${environmentId}/identities` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "safe" },
                     pathParams: { traffic_type_id: "trafficTypeId", environment_id: "environmentId" },
+                    paramsSchema: {
+                        fields: [
+                            { name: "org_id", required: false, description: "Optional — pass together with project_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
+                            { name: "project_id", required: false, description: "Optional — pass together with org_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
+                        ],
+                    },
                     skipScopeBodyInjection: true,
                     bodyBuilder: (input) => {
                         const body = input.body;
@@ -572,8 +1159,23 @@ export const featureFlagsToolset = {
                 update: {
                     method: "PATCH",
                     path: "/internal/api/v2/trafficTypes/{trafficTypeId}/environments/{environmentId}/identities/{key}",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_identity.update")) {
+                            throw new Error("fme_identity.update: Harness-native (org_id/project_id) mode not yet implemented for this operation — pass traffic_type_id/environment_id (current contract) instead.");
+                        }
+                        const trafficTypeId = encodeURIComponent(requireFmeIdentifier(input, "traffic_type_id", "fme_identity"));
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_identity"));
+                        const key = encodeURIComponent(requireFmeIdentifier(input, "key", "fme_identity"));
+                        return { path: `/internal/api/v2/trafficTypes/${trafficTypeId}/environments/${environmentId}/identities/${key}` };
+                    },
                     operationPolicy: { risk: "low_write", retryPolicy: "safe" },
                     pathParams: { traffic_type_id: "trafficTypeId", environment_id: "environmentId", key: "key" },
+                    paramsSchema: {
+                        fields: [
+                            { name: "org_id", required: false, description: "Optional — pass together with project_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
+                            { name: "project_id", required: false, description: "Optional — pass together with org_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
+                        ],
+                    },
                     bodyBuilder: (input) => input.body,
                     responseExtractor: passthrough,
                     bodySchema: fmeIdentityUpdateSchema,
@@ -584,51 +1186,244 @@ export const featureFlagsToolset = {
         // ── FME Standard Segments ─────────────────────────────────────────────
         {
             resourceType: "fme_standard_segment",
-            displayName: "FME Standard Segment",
-            description: "Standard (static list) segment in a workspace. List all segments to see names, descriptions, and member counts. For member management, use fme_segment_keys.",
+            displayName: "(Deprecated) FME Standard Segment",
+            description: "Deprecated — use fme_segment instead for new integrations. Standard (static list) segment in a workspace. List all segments to see names, descriptions, and member counts, via the legacy workspace_id contract only — org_id+project_id (Harness-native) is rejected on every operation here in favor of fme_segment. For member management, use fme_segment_keys.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["workspace_id", "segment_name"],
             product: "fme",
             listFilterFields: [
-                { name: "workspace_id", description: "Workspace ID (get from fme_workspace)", required: true },
+                { name: "workspace_id", description: "Workspace ID (get from fme_workspace). This resource only supports the legacy workspace_id contract; use fme_segment for Harness-native org_id+project_id scoping." },
             ],
             operations: {
                 list: {
                     method: "GET",
-                    path: "/internal/api/v2/segments/ws/{wsId}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_standard_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_standard_segment.list: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead.");
+                        }
+                        return { path: `/internal/api/v2/segments/ws/${encodeURIComponent(mode.workspaceId)}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId" },
                     responseExtractor: passthrough,
                     description: "List all standard segments in a workspace. Returns segment name, description, and creation metadata.",
                 },
                 get: {
                     method: "GET",
-                    path: "/internal/api/v2/segments/ws/{wsId}/{segmentName}",
+                    path: "",
+                    routeResolver: (input) => {
+                        const mode = resolveFmeDualMode(input, "fme_standard_segment");
+                        if (mode.mode === "harness_native") {
+                            throw new Error("fme_standard_segment.get: Harness-native (org_id/project_id) mode is not supported on this deprecated resource — use fme_segment instead.");
+                        }
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_standard_segment"));
+                        return { path: `/internal/api/v2/segments/ws/${encodeURIComponent(mode.workspaceId)}/${segmentName}` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
-                    pathParams: { workspace_id: "wsId", segment_name: "segmentName" },
                     responseExtractor: passthrough,
                     description: "Get a standard segment's metadata by name.",
                 },
             },
         },
+        {
+            resourceType: "fme_segment",
+            displayName: "FME Segment",
+            description: "FME (Harness-native, org_id+project_id scoped). Unified segment type (standard, rule-based, and large). Supports list, get, create, delete. create requires body.type (\"standard\" | \"rule_based\" | \"large\").",
+            toolset: "feature-flags",
+            scope: "project",
+            scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+            identifierFields: ["segment_name"],
+            operations: {
+                list: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment");
+                        return { path: "/fme/api/v4/segments" };
+                    },
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    responseExtractor: passthrough,
+                    description: "List all segments (standard and rule-based) in project.",
+                },
+                get: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment"));
+                        return { path: `/fme/api/v4/segments/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    responseExtractor: passthrough,
+                    description: "Get single segment by name.",
+                },
+                delete: {
+                    method: "DELETE",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment"));
+                        return { path: `/fme/api/v4/segments/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
+                    responseExtractor: passthrough,
+                    description: "Delete a segment by name.",
+                },
+                create: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment");
+                        return { path: "/fme/api/v4/segments" };
+                    },
+                    operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
+                    bodyBuilder: (input) => {
+                        const body = input.body;
+                        const trafficType = (body?.trafficType ?? body?.traffic_type);
+                        if (body?.type !== undefined && !FME_SEGMENT_TYPES.includes(body.type)) {
+                            throw new Error(`fme_segment.create: invalid type '${body.type}'. Must be one of: ${FME_SEGMENT_TYPES.join(", ")}.`);
+                        }
+                        return {
+                            name: body?.name,
+                            trafficType,
+                            type: body?.type,
+                            ...(body?.description !== undefined ? { description: body.description } : {}),
+                            ...(body?.tags !== undefined ? { tags: normalizeFmeTags(body.tags) } : {}),
+                            ...(body?.owners !== undefined ? { owners: body.owners } : {}),
+                        };
+                    },
+                    responseExtractor: passthrough,
+                    bodySchema: fmeSegmentCreateSchema,
+                    description: "Create a new segment. Body requires name + trafficType + type (\"standard\" | \"rule_based\" | \"large\"); optional description, tags, owners.",
+                },
+            },
+        },
+        // ── FME Segment Definition (Harness-native, unified — Harness_Split/Main PR #12644) ──
+        {
+            resourceType: "fme_segment_definition",
+            displayName: "FME Segment Definition",
+            description: "Environment-specific definition of a segment (standard or rule-based) — description and lifecycle. Replaces fme_rule_based_segment_definition's role in Harness-native calls, generalized for all segment types. Harness-native only (org_id+project_id; no legacy workspace_id support). Supports list, get, create, update (description only, via JSON Merge Patch), and delete. Wired against Harness_Split/Main PR #12644, which was open (not yet merged) as of this writing — paths may still change before merge. There is no enable/disable/change_request action: the backend has no such endpoints for this unified resource; governance checks are surfaced inline in the create/update/delete responses instead.",
+            toolset: "feature-flags",
+            scope: "project",
+            scopeParams: FME_HARNESS_NATIVE_SCOPE_PARAMS,
+            identifierFields: ["segment_name", "environment_id"],
+            listFilterFields: [
+                { name: "environment_id", description: "FME environment ID (get from fme_environment)", required: true },
+                { name: "status", description: "Filter by definition status", enum: ["ACTIVE", "ARCHIVED"] },
+                { name: "offset", description: "Pagination offset", type: "number" },
+                { name: "limit", description: "Page size (max 100, default 100)", type: "number" },
+            ],
+            operations: {
+                list: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment_definition");
+                        return { path: "/fme/api/v4/segment-definitions" };
+                    },
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    queryParams: { environment_id: "environment_id", status: "status", offset: "offset", limit: "limit" },
+                    responseExtractor: passthrough,
+                    description: "List segment definitions in an environment, with pagination (offset/limit, max 100) and an optional status filter.",
+                },
+                get: {
+                    method: "GET",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment_definition");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_definition"));
+                        return { path: `/fme/api/v4/segment-definitions/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "read", retryPolicy: "safe" },
+                    queryParams: { environment_id: "environment_id" },
+                    responseExtractor: passthrough,
+                    description: "Get a single segment definition by name in an environment.",
+                },
+                create: {
+                    method: "POST",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment_definition");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_definition"));
+                        return { path: `/fme/api/v4/segment-definitions/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "low_write", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    bodyBuilder: (input) => {
+                        const body = input.body;
+                        return body?.description !== undefined ? { description: body.description } : {};
+                    },
+                    responseExtractor: passthrough,
+                    bodySchema: fmeSegmentDefinitionCreateSchema,
+                    description: "Create a segment definition in an environment. Omit the description (or send an empty body) to create an empty/default shell.",
+                },
+                update: {
+                    method: "PATCH",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment_definition");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_definition"));
+                        return { path: `/fme/api/v4/segment-definitions/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "low_write", retryPolicy: "safe" },
+                    queryParams: { environment_id: "environment_id" },
+                    headers: { "Content-Type": "application/merge-patch+json" },
+                    bodyBuilder: (input) => {
+                        const body = input.body;
+                        if (!body || !("description" in body))
+                            return {};
+                        return { description: body.description };
+                    },
+                    responseExtractor: passthrough,
+                    bodySchema: fmeSegmentDefinitionUpdateSchema,
+                    description: "Update a segment definition's description via JSON Merge Patch (RFC 7396) — the only mutable field. Omit description to leave it unchanged, pass null to clear it, or a string to set it.",
+                },
+                delete: {
+                    method: "DELETE",
+                    path: "",
+                    routeResolver: (input) => {
+                        requireHarnessNativeSegmentScope(input, "fme_segment_definition");
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_definition"));
+                        return { path: `/fme/api/v4/segment-definitions/${segmentName}` };
+                    },
+                    operationPolicy: { risk: "destructive", retryPolicy: "do_not_retry" },
+                    queryParams: { environment_id: "environment_id" },
+                    responseExtractor: passthrough,
+                    description: "Delete a segment definition from an environment.",
+                },
+            },
+        },
         {
             resourceType: "fme_segment_keys",
             displayName: "FME Segment Keys",
             description: "Membership keys (members) of a standard segment. List keys with pagination, or update to add members. Removal is not supported by this endpoint. Limit: 10,000 keys per request, 100,000 per segment total.",
             toolset: "feature-flags",
             scope: "account",
+            scopeOptional: true,
             identifierFields: ["environment_id", "segment_name"],
             product: "fme",
             listFilterFields: [
                 { name: "environment_id", description: "Environment ID (get from fme_environment)", required: true },
                 { name: "segment_name", description: "Segment name", required: true },
                 { name: "offset", description: "Pagination offset", type: "number" },
+                { name: "org_id", description: "Optional — pass together with project_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
+                { name: "project_id", description: "Optional — pass together with org_id to select the (not yet implemented) Harness-native mode instead of the current contract." },
             ],
             operations: {
                 list: {
                     method: "GET",
                     path: "/internal/api/v2/segments/{environmentId}/{segmentName}/keys",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_segment_keys.list")) {
+                            throw new Error("fme_segment_keys.list: Harness-native (org_id/project_id) mode not yet implemented for this operation — pass environment_id/segment_name (current contract) instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_segment_keys"));
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_keys"));
+                        return { path: `/internal/api/v2/segments/${environmentId}/${segmentName}/keys` };
+                    },
                     operationPolicy: { risk: "read", retryPolicy: "safe" },
                     pathParams: { environment_id: "environmentId", segment_name: "segmentName" },
                     queryParams: {
@@ -641,6 +1436,14 @@ export const featureFlagsToolset = {
                 update: {
                     method: "PUT",
                     path: "/internal/api/v2/segments/{environmentId}/{segmentName}/upload",
+                    routeResolver: (input) => {
+                        if (isFmeHarnessNativeSelected(input, "fme_segment_keys.update")) {
+                            throw new Error("fme_segment_keys.update: Harness-native (org_id/project_id) mode not yet implemented for this operation — pass environment_id/segment_name (current contract) instead.");
+                        }
+                        const environmentId = encodeURIComponent(requireFmeIdentifier(input, "environment_id", "fme_segment_keys"));
+                        const segmentName = encodeURIComponent(requireFmeIdentifier(input, "segment_name", "fme_segment_keys"));
+                        return { path: `/internal/api/v2/segments/${environmentId}/${segmentName}/upload` };
+                    },
                     operationPolicy: { risk: "medium_write", retryPolicy: "do_not_retry" },
                     pathParams: { environment_id: "environmentId", segment_name: "segmentName" },
                     skipScopeBodyInjection: true,